<!DOCTYPE html>
<!-- Sources at https://github.com/cplusplus/fundamentals-ts -->
<html lang="en"><head><!--[if lte IE 8]><script>document.createElement("nav");document.createElement("section");document.createElement("time");document.createElement("CXX-TITLEPAGE");document.createElement("CXX-DOCNUM");document.createElement("CXX-PROJECT-NUMBER");document.createElement("CXX-TOC");document.createElement("CXX-CLAUSE");document.createElement("CXX-SECTION");document.createElement("CXX-REF");document.createElement("CXX-FOREIGN-INDEX");document.createElement("CXX-EDNOTE");document.createElement("CXX-EXAMPLE");document.createElement("CXX-NOTE");document.createElement("CXX-FUNCTION");document.createElement("CXX-SIGNATURE");document.createElement("CXX-REMARKS");document.createElement("CXX-EFFECTS");document.createElement("CXX-TERM");document.createElement("W-BR");document.createElement("CXX-RETURNS");document.createElement("CXX-POSTCONDITIONS");document.createElement("CXX-REQUIRES");document.createElement("CXX-RANGE");document.createElement("CXX-THROWS");document.createElement("CXX-COMPLEXITY");document.createElement("CXX-NOTES");document.createElement("CXX-FOOTNOTE");document.createElement("CXX-EXCEPTION-SAFETY");document.createElement("CXX-FIGURE");document.createElement("CXX-PUBLISH-BUTTON");</script><![endif]--><style>template {display: none !important;} /* injected by platform.js */</style><style>body {transition: opacity ease-in 0.2s; } 
body[unresolved] {opacity: 0; display: block; overflow: hidden; position: relative; } 
</style><style shim-shadowdom-css="">style { display: none !important; }
cxx-function {
	display: block; page-break-inside: avoid;
}

cxx-function:not(:last-child) {
	margin-bottom: 3ex;
}

cxx-function > dl {
	margin: 0px 0px 0px 2em;
}

cxx-function > pre {
	margin: 0px;
}cxx-signature {
	padding-left: 2em; display: block; text-indent: -2em;
}

cxx-signature.formatted {
	text-indent: 0px;
}cxx-attribute {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-attribute dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-attribute dd {
	margin-left: 0em;
}

cxx-attribute dd > ul, cxx-attribute dd > ol {
	clear: left;
}cxx-requires {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-requires dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-requires dd {
	margin-left: 0em;
}

cxx-requires dd > ul, cxx-requires dd > ol {
	clear: left;
}cxx-preconditions {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-preconditions dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-preconditions dd {
	margin-left: 0em;
}

cxx-preconditions dd > ul, cxx-preconditions dd > ol {
	clear: left;
}cxx-effects {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-effects dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-effects dd {
	margin-left: 0em;
}

cxx-effects dd > ul, cxx-effects dd > ol {
	clear: left;
}cxx-synchronization {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-synchronization dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-synchronization dd {
	margin-left: 0em;
}

cxx-synchronization dd > ul, cxx-synchronization dd > ol {
	clear: left;
}cxx-postconditions {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-postconditions dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-postconditions dd {
	margin-left: 0em;
}

cxx-postconditions dd > ul, cxx-postconditions dd > ol {
	clear: left;
}cxx-returns {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-returns dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-returns dd {
	margin-left: 0em;
}

cxx-returns dd > ul, cxx-returns dd > ol {
	clear: left;
}cxx-throws {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-throws dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-throws dd {
	margin-left: 0em;
}

cxx-throws dd > ul, cxx-throws dd > ol {
	clear: left;
}cxx-complexity {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-complexity dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-complexity dd {
	margin-left: 0em;
}

cxx-complexity dd > ul, cxx-complexity dd > ol {
	clear: left;
}cxx-exception-safety {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-exception-safety dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-exception-safety dd {
	margin-left: 0em;
}

cxx-exception-safety dd > ul, cxx-exception-safety dd > ol {
	clear: left;
}cxx-remarks {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-remarks dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-remarks dd {
	margin-left: 0em;
}

cxx-remarks dd > ul, cxx-remarks dd > ol {
	clear: left;
}cxx-error-conditions {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-error-conditions dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-error-conditions dd {
	margin-left: 0em;
}

cxx-error-conditions dd > ul, cxx-error-conditions dd > ol {
	clear: left;
}cxx-notes {
	display: block; margin-top: 0.5em; margin-bottom: 0.5em;
}

cxx-notes dt {
	float: left; font-style: italic; font-weight: normal; padding-right: 1ex;
}

cxx-notes dd {
	margin-left: 0em;
}

cxx-notes dd > ul, cxx-notes dd > ol {
	clear: left;
}cxx-section {
	display: block;
}

cxx-section:target {
	background-color: inherit;
}

cxx-section:target > section > h1 {
	background-color: rgb(255, 238, 221);
}

cxx-section header > h1 {
	display: inline; font-size: 100%;
}

cxx-section header {
	font-weight: bold; margin-top: 20px; margin-bottom: 20px; page-break-inside: avoid; page-break-after: avoid;
}

cxx-section header::after {
	clear: both; display: block; content: " "; height: 0px;
}cxx-clause {
	display: block;
}

cxx-clause:target {
	background-color: inherit;
}

cxx-clause:target > section > h1 {
	background-color: rgb(255, 238, 221);
}

cxx-clause header > h1 {
	display: inline; font-size: 100%;
}

cxx-clause header {
	font-weight: bold; margin-top: 20px; margin-bottom: 20px; page-break-inside: avoid; page-break-after: avoid;
}

cxx-clause header::after {
	clear: both; display: block; content: " "; height: 0px;
}[is=cxx-table] {
	margin-left: auto; margin-right: auto; border-collapse: collapse; border: thin solid black;
}

[is=cxx-table] caption {
	white-space: nowrap;
}

[is=cxx-table] caption caption {
	display: inline;
}

[is=cxx-table] th, [is=cxx-table] td {
	border-style: solid none; border-color: black; border-width: thin; padding: 0px 0.25em;
}

[is=cxx-table].column-rules th, [is=cxx-table].column-rules td {
	border-left-style: solid; border-right-style: solid;
}

[is=cxx-table] th {
	border-bottom: medium double;
}

[is=cxx-table].single-border th {
	border-bottom: thin solid;
}

[is=cxx-table].center td {
	text-align: center;
}

[is=cxx-table].list td {
	border: medium none; vertical-align: top;
}

[is=cxx-table].list ul {
	padding-left: 0px; margin: 0px;
}

[is=cxx-table].list ul li::before {
	content: "";
}cxx-figure {
	margin-left: auto; margin-right: auto;
}

cxx-figure figcaption {
	white-space: nowrap; text-align: center;
}

cxx-figure figcaption figcaption {
	display: inline;
}[is=cxx-definition-section] dt {
	font-weight: bold;
}

[is=cxx-definition-section] dd {
	margin-left: 0px;
}cxx-toc {
	display: block;
}

cxx-toc nav > ol {
	font-weight: bold;
}

cxx-toc ol {
	font-weight: normal; padding-left: 0px; margin-left: 0px;
}

cxx-toc li {
	list-style-type: none;
}

cxx-toc .marker {
	display: inline-block;
}

cxx-toc li .marker {
	width: 2em; text-align: left;
}

cxx-toc ol ol {
	margin-left: 2em;
}

cxx-toc li li .marker {
	width: 3em;
}

cxx-toc ol ol ol {
	margin-left: 3em;
}

cxx-toc li li li .marker {
	width: 3.5em;
}

cxx-toc ol ol ol ol {
	margin-left: 3.5em;
}

cxx-toc li li li li .marker {
	width: 4.5em;
}cxx-get-element-by-id {
	display: none;
}cxx-foreign-index {
	display: none;
}cxx-titlepage, cxx-titlepage .page {
	display: block; min-height: 100%;
}

cxx-titlepage .page {
	page-break-before: always; page-break-after: always; min-height: 100vh; margin-bottom: 2em;
}

@media print {
cxx-titlepage .page {
	height: 8.8in;
}


}

cxx-titlepage .page {
	position: relative;
}

cxx-titlepage table td, cxx-titlepage table th {
	border: medium none;
}

cxx-titlepagebody.cxx-draft .header, body.cxx-draft cxx-titlepage .header {
	position: absolute; right: 0px; top: 0px;
}

cxx-titlepagebody.cxx-draft h1, body.cxx-draft cxx-titlepage h1 {
	position: absolute; top: 40%; text-align: center;
}

cxx-titlepagebody.cxx-draft p.warning, body.cxx-draft cxx-titlepage p.warning {
	position: absolute; bottom: 5%;
}

cxx-titlepagebody.cxx-pdts .header, body.cxx-pdts cxx-titlepage .header, cxx-titlepagebody.cxx-dts .header, body.cxx-dts cxx-titlepage .header {
	position: absolute; right: 0px; top: 0px; text-align: right;
}

cxx-titlepagebody.cxx-pdts .header cxx-docnum, body.cxx-pdts cxx-titlepage .header cxx-docnum, cxx-titlepagebody.cxx-dts .header cxx-docnum, body.cxx-dts cxx-titlepage .header cxx-docnum {
	font-size: 150%;
}

cxx-titlepagebody.cxx-pdts .header cxx-docnum, body.cxx-pdts cxx-titlepage .header cxx-docnum, cxx-titlepagebody.cxx-dts .header cxx-docnum, body.cxx-dts cxx-titlepage .header cxx-docnum {
	font-size: 150%;
}

cxx-titlepagebody.cxx-pdts hgroup, body.cxx-pdts cxx-titlepage hgroup, cxx-titlepagebody.cxx-dts hgroup, body.cxx-dts cxx-titlepage hgroup {
	position: absolute; top: 30%;
}

cxx-titlepagebody.cxx-pdts hgroup *, body.cxx-pdts cxx-titlepage hgroup *, cxx-titlepagebody.cxx-dts hgroup *, body.cxx-dts cxx-titlepage hgroup * {
	margin: 0px;
}

cxx-titlepagebody.cxx-pdts hgroup h1, body.cxx-pdts cxx-titlepage hgroup h1, cxx-titlepagebody.cxx-dts hgroup h1, body.cxx-dts cxx-titlepage hgroup h1 {
	font-size: 150%; font-weight: bold;
}

cxx-titlepagebody.cxx-pdts hgroup h2, body.cxx-pdts cxx-titlepage hgroup h2, cxx-titlepagebody.cxx-dts hgroup h2, body.cxx-dts cxx-titlepage hgroup h2 {
	font-size: 100%; font-weight: normal;
}

cxx-titlepagebody.cxx-pdts .footer, body.cxx-pdts cxx-titlepage .footer, cxx-titlepagebody.cxx-dts .footer, body.cxx-dts cxx-titlepage .footer {
	position: absolute; left: 0px; bottom: 5%;
}

cxx-titlepagebody.cxx-pdts figure, body.cxx-pdts cxx-titlepage figure, cxx-titlepagebody.cxx-dts figure, body.cxx-dts cxx-titlepage figure {
	border: 1px solid rgb(17, 17, 17); padding: 10px; margin-left: auto; margin-right: auto;
}

cxx-titlepagebody.cxx-pdts figcaption, body.cxx-pdts cxx-titlepage figcaption, cxx-titlepagebody.cxx-dts figcaption, body.cxx-dts cxx-titlepage figcaption {
	text-align: center; font-weight: bold;
}

cxx-titlepagebody.cxx-pdts .warning, body.cxx-pdts cxx-titlepage .warning, cxx-titlepagebody.cxx-dts .warning, body.cxx-dts cxx-titlepage .warning {
	position: absolute; bottom: 20%;
}

cxx-titlepagebody.cxx-pdts .copyright address, body.cxx-pdts cxx-titlepage .copyright address, cxx-titlepagebody.cxx-dts .copyright address, body.cxx-dts cxx-titlepage .copyright address {
	font-style: normal; margin-left: 2em;
}

cxx-titlepagebody.cxx-pdts .copyright address a, body.cxx-pdts cxx-titlepage .copyright address a, cxx-titlepagebody.cxx-dts .copyright address a, body.cxx-dts cxx-titlepage .copyright address a {
	color: inherit; text-decoration: inherit;
}

cxx-titlepage th {
	text-align: left; vertical-align: top;
}cxx-ednote {
	display: block;
}

cxx-ednotebody.cxx-pdts, body.cxx-pdts cxx-ednote {
	display: none;
}

cxx-ednote aside {
	float: right; max-width: 40%; margin: 1ex; border: 1px dashed rgb(136, 136, 136); padding: 1ex; background-color: rgb(238, 238, 238);
}

cxx-ednote.para aside {
	float: none; max-width: none;
}cxx-note .nowrap {
	white-space: nowrap;
}cxx-footnote {
	font-family: serif; white-space: normal; text-indent: initial;textIndent: initial; text-indent: initial; 
}

@media screen {
cxx-footnote aside {
	float: right; max-width: 30%; margin-left: 1em;
}


}

@media print {
cxx-footnote sup, cxx-footnote .marker {
	display: none;
}

cxx-footnote aside {
	
}


}cxx-example {
	display: block;
}

cxx-example.inline {
	display: inline;
}

cxx-example .nowrap {
	white-space: nowrap;
}cxx-publish-button {
	display: block;
}cxx-codeblock {
	display: block;
}bnf-grammar {
	display: block; font-style: italic; margin-left: 0.35in;
}bnf-rule {
	display: block; margin-left: 0.6in;
}bnf-alt {
	display: block; margin-left: 1.2in;
}bnf-terminal {
	font-style: normal;
}w-br {
	white-space: normal;
}

w-br::after {
	content: "​";
}</style>
  <meta charset="utf-8">
  
  <style shim-shadowdom-css="">/* Copyright 2014 Google Inc. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

@page {
    margin: 10%;
    @top-left { content: "© ISO/IEC"; font-size: 10pt; }
    @top-right { content: string(docnum); font-weight: bold; font-size: 10pt; }
    @bottom-left { content: string(current-section, last); font-size: 10pt; }
    @bottom-right { content: counter(page); font-size: 10pt; }
}
@page :first {
    /* @top-left is defined by base.js. */
    @top-right { content: normal; }
    @bottom-left { content: normal; }
    @bottom-right { content: normal; }
}

body { margin: 0; }

@media screen {
    body { max-width: 7in;
           /* Make room for paragraph numbers. */
           margin-left: 2em }
}

@media print {
    html { font-size: 10pt; }
    *   code { font-size: 80%; }
    /* Note that only Prince generates clickable links. */
    *   a[href] { text-decoration:none; }
}

@media screen {
    /* Needed to make the <cxx-titlepage>'s vertical spacing work.
       For print see the <cxx-titlepage> definition. */
    html, body {height: 100%}
}

cxx-docnum { string-set: docnum content(); }

cxx-clause { page-break-before: always; }
@media screen {
    cxx-clause, cxx-toc { margin-top: 3em; }
}

cxx-clause  header { font-size: 150%; }
cxx-toc  h1 { font-size: 150%; }
cxx-clause cxx-section  header { font-size: 117%; }
cxx-clause cxx-section cxx-section  header { font-size: 100%; }

[data-bookmark-label] { bookmark-label: attr(data-bookmark-label); }
h1 { bookmark-level: 1; }
cxx-toc  h1 { bookmark-level: 2; }
cxx-clause h1 { bookmark-level: 2; }
cxx-clause cxx-section h1 { bookmark-level: 3; }
cxx-clause cxx-section cxx-section h1 { bookmark-level: 4; }
/* The <h2> is a subtitle, which shouldn't get a PDF bookmark. */
cxx-titlepage  h2 { bookmark-level: none; }

*  .section-number { string-set: current-section "§ " content(); }

p {margin-top: .5em; margin-bottom: .5em}
p:first-child, ul, ol {margin-top: 0}

[para_num]::before { content: attr(para_num); float: left;
                     font-size: 70%; margin-left: -2.5em; width: 1.5em; text-align: right; }

del {text-decoration: line-through; color: #8B0040;}
ins {text-decoration: underline; color: #005100;}

pre {
    margin-left: 1em;
    margin-top: .5em;
    margin-bottom: .5em;
}

*   wbr::after {
    white-space: normal;
    content: '\200B';
}
*   code {
    /* Make inline code avoid line wraps unless we override it with <wbr>. */
    white-space: nowrap;
}
*   pre code {
    /* Keep block-code wrapping according to its context. */
    white-space: inherit;
}

*   table {
    border-collapse: collapse;
}
*   td, th {
    padding-left: .2em;
    padding-right: .2em;
    border: thin solid black;
}

/* Use an em-dash for the list bullet.
   'print' is a proxy for supporting ::marker. */
@media screen {
    ul {
        list-style: none;
        /* Relative positioning on the 'ul' lets the absolutely-positioned
           marker align relative to it.*/
        position: relative;
    }
    ul li:before {
        content: "\2014";
        position: absolute; left: 10px;
    }
}
@media print {
    ul li::marker {
        content: "\2014";
    }
    [is=cxx-table].list ul li::marker {
        content: none;
    }
}

/* This is here rather than inside elements/toc.html because browsers
   don't understand leader() or target-counter(), so they drop them
   inside the CSSOM. */
@media print {
    /* Generate page numbers in the table of contents. */
    cxx-toc  a[href]::after { content: leader(" . ") target-counter(attr(href), page); }

    cxx-footnote  aside { float: footnote; footnote-policy: line; }
}</style><style shim-shadowdom-css="">/*******************************
          Flex Layout
*******************************/

html   [layout][horizontal], html   [layout][vertical] {
  display: -ms-flexbox;
  display: -webkit-flex;
  display: flex;
}

html   [layout][horizontal][inline], html   [layout][vertical][inline] {
  display: -ms-inline-flexbox;
  display: -webkit-inline-flex;
  display: inline-flex;
}

html   [layout][horizontal] {
  -ms-flex-direction: row;
  -webkit-flex-direction: row;
  flex-direction: row;
}

html   [layout][horizontal][reverse] {
  -ms-flex-direction: row-reverse;
  -webkit-flex-direction: row-reverse;
  flex-direction: row-reverse;
}

html   [layout][vertical] {
  -ms-flex-direction: column;
  -webkit-flex-direction: column;
  flex-direction: column;
}

html   [layout][vertical][reverse] {
  -ms-flex-direction: column-reverse;
  -webkit-flex-direction: column-reverse;
  flex-direction: column-reverse;
}

html   [layout][wrap] {
  -ms-flex-wrap: wrap;
  -webkit-flex-wrap: wrap;
  flex-wrap: wrap;
}

html   [layout][wrap-reverse] {
  -ms-flex-wrap: wrap-reverse;
  -webkit-flex-wrap: wrap-reverse;
  flex-wrap: wrap-reverse;
}

html   [flex] {
  -ms-flex: 1 1 0.000000001px;
  -webkit-flex: 1;
  flex: 1;
  -webkit-flex-basis: 0.000000001px;
  flex-basis: 0.000000001px;
}

html   [vertical][layout] > [flex][auto-vertical], html   [vertical][layout]  [flex][auto-vertical] {
  -ms-flex: 1 1 auto;
  -webkit-flex-basis: auto;
  flex-basis: auto;
}

html   [flex][auto] {
  -ms-flex: 1 1 auto;
  -webkit-flex-basis: auto;
  flex-basis: auto;
}

html   [flex][none] {
  -ms-flex: none;
  -webkit-flex: none;
  flex: none;
}

html   [flex][one] {
  -ms-flex: 1;
  -webkit-flex: 1;
  flex: 1;
}

html   [flex][two] {
  -ms-flex: 2;
  -webkit-flex: 2;
  flex: 2;
}

html   [flex][three] {
  -ms-flex: 3;
  -webkit-flex: 3;
  flex: 3;
}

html   [flex][four] {
  -ms-flex: 4;
  -webkit-flex: 4;
  flex: 4;
}

html   [flex][five] {
  -ms-flex: 5;
  -webkit-flex: 5;
  flex: 5;
}

html   [flex][six] {
  -ms-flex: 6;
  -webkit-flex: 6;
  flex: 6;
}

html   [flex][seven] {
  -ms-flex: 7;
  -webkit-flex: 7;
  flex: 7;
}

html   [flex][eight] {
  -ms-flex: 8;
  -webkit-flex: 8;
  flex: 8;
}

html   [flex][nine] {
  -ms-flex: 9;
  -webkit-flex: 9;
  flex: 9;
}

html   [flex][ten] {
  -ms-flex: 10;
  -webkit-flex: 10;
  flex: 10;
}

html   [flex][eleven] {
  -ms-flex: 11;
  -webkit-flex: 11;
  flex: 11;
}

html   [flex][twelve] {
  -ms-flex: 12;
  -webkit-flex: 12;
  flex: 12;
}

/* alignment in cross axis */

html   [layout][start] {
  -ms-flex-align: start;
  -webkit-align-items: flex-start;
  align-items: flex-start;
}

html   [layout][center], html   [layout][center-center] {
  -ms-flex-align: center;
  -webkit-align-items: center;
  align-items: center;
}

html   [layout][end] {
  -ms-flex-align: end;
  -webkit-align-items: flex-end;
  align-items: flex-end;
}

/* alignment in main axis */

html   [layout][start-justified] {
  -ms-flex-pack: start;
  -webkit-justify-content: flex-start;
  justify-content: flex-start;
}

html   [layout][center-justified], html   [layout][center-center] {
  -ms-flex-pack: center;
  -webkit-justify-content: center;
  justify-content: center;
}

html   [layout][end-justified] {
  -ms-flex-pack: end;
  -webkit-justify-content: flex-end;
  justify-content: flex-end;
}

html   [layout][around-justified] {
  -ms-flex-pack: distribute;
  -webkit-justify-content: space-around;
  justify-content: space-around;
}

html   [layout][justified] {
  -ms-flex-pack: justify;
  -webkit-justify-content: space-between;
  justify-content: space-between;
}

/* self alignment */

html   [self-start] {
  -ms-align-self: flex-start;
  -webkit-align-self: flex-start;
  align-self: flex-start;
}

html   [self-center] {
  -ms-align-self: center;
  -webkit-align-self: center;
  align-self: center;
}

html   [self-end] {
  -ms-align-self: flex-end;
  -webkit-align-self: flex-end;
  align-self: flex-end;
}

html   [self-stretch] {
  -ms-align-self: stretch;
  -webkit-align-self: stretch;
  align-self: stretch;
}

/*******************************
          Other Layout
*******************************/

html   [block] {
  display: block;
}

/* ie support for hidden */
html   [hidden] {
  display: none !important;
}

html   [relative] {
  position: relative;
}

html   [fit] {
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
}

body[fullbleed] {
  margin: 0;
  height: 100vh;
}

/*******************************
            Other
*******************************/

html   [segment], html   segment {
  display: block;
  position: relative;
  -webkit-box-sizing: border-box;
  -ms-box-sizing: border-box;
  box-sizing: border-box;
  margin: 1em 0.5em;
  padding: 1em;
  background-color: white;
  -webkit-box-shadow: 0px 0px 0px 1px rgba(0, 0, 0, 0.1);
  box-shadow: 0px 0px 0px 1px rgba(0, 0, 0, 0.1);
  border-radius: 5px 5px 5px 5px;
}</style>
<style>@page :first { @top-left { content: "© ISO 2015 — All rights reserved"; } }</style><title>C++ Extensions for Library Fundamentals, DTS</title></head>
<body class="cxx-dts">
<cxx-titlepage>
    
    

    
      <div class="page">
        <div class="header">
          <strong>ISO/IEC JTC1 SC22 WG21 <cxx-docnum>N4480</cxx-docnum></strong><br>
          Date: <time pubdate="">2015-04-07</time><br>
          
          
            ISO/IEC DTS <cxx-project-number>19568</cxx-project-number><br>
          
          ISO/IEC JTC1 SC22<br>
          Secretariat: ANSI
        </div>
        <hgroup>
          <h1>Programming Languages — C++ Extensions for Library Fundamentals</h1>
          
            <h2>Langages de programmation — Extensions C++ pour la bibliothèque fondamentaux</h2>
          
        </hgroup>
        <figure class="warning">
          <figcaption>Warning</figcaption>
          <p>This document is not an ISO International Standard. It is distributed for review and comment. It is
          subject to change without notice and may not be referred to as an International Standard.
          </p>
          <p>Recipients of this draft are invited to submit, with their comments, notification of any relevant
          patent rights of which they are aware and to provide supporting documentation.</p>
        </figure>
        <div class="footer">
          
          
            Document type: Draft Technical Specification<br>
            Document stage: (40) Enquiry<br>
          
          Document language: E
        </div>
      </div>
      <div class="page">
        <figure class="copyright">
          <figcaption>Copyright notice</figcaption>
          <p>This ISO document is a working draft or committee draft and is copyright-protected by ISO. While
          the reproduction of working drafts or committee drafts in any form for use by participants in the
          ISO standards development process is permitted without prior permission from ISO, neither this
          document nor any extract from it may be reproduced, stored or transmitted in any form for any
          other purpose without prior written permission from ISO.</p>
          <p>Requests for permission to reproduce this document for the purpose of selling it should be
          addressed as shown below or to ISO’s member body in the country of the requester:</p>
          <address>
            ISO copyright officer<br>
            Case postale 56, CH-1211 Geneva 20<br>
            Tel. + 41 22 749 01 11<br>
            Fax + 41 22 749 09 47<br>
            E-mail <a href="mailto:copyright@iso.org">copyright@iso.org</a><br>
            Web <a href="http://www.iso.org/">www.iso.org</a>
          </address>
          <p>Reproduction may be subject to royalty payments or a licensing agreement.</p>
          <p>Violators may be prosecuted.</p>
        </figure>
      </div>
    

    
  </cxx-titlepage>

<cxx-toc>
    
    <nav>
      <h1>Contents</h1>
      
        
          <ol>
            
              <li><span class="marker">1</span><a href="#general">General</a>
        
          <ol>
            
              <li><span class="marker">1.1</span><a href="#general.scope">Scope</a>
        
      </li>
            
              <li><span class="marker">1.2</span><a href="#general.references">Normative references</a>
        
      </li>
            
              <li><span class="marker">1.3</span><a href="#general.namespaces">Namespaces, headers, and modifications to standard classes</a>
        
      </li>
            
              <li><span class="marker">1.4</span><a href="#general.defns">Terms and definitions</a>
        
      </li>
            
              <li><span class="marker">1.5</span><a href="#general.plans">Future plans (Informative)</a>
        
      </li>
            
              <li><span class="marker">1.6</span><a href="#general.feature.test">Feature-testing recommendations (Informative)</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">2</span><a href="#mods">Modifications to the C++ Standard Library</a>
        
          <ol>
            
              <li><span class="marker">2.1</span><a href="#mods.allocator.uses">Uses-allocator construction</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">3</span><a href="#utilities">General utilities library</a>
        
          <ol>
            
              <li><span class="marker">3.1</span><a href="#utility">Utility components</a>
        
          <ol>
            
              <li><span class="marker">3.1.1</span><a href="#utility.synop">Header &lt;experimental/utility&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">3.1.2</span><a href="#utility.erased.type">Class erased_type</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">3.2</span><a href="#tuple">Tuples</a>
        
          <ol>
            
              <li><span class="marker">3.2.1</span><a href="#header.tuple.synop">Header &lt;experimental/tuple&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">3.2.2</span><a href="#tuple.apply">Calling a function with a tuple of arguments</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">3.3</span><a href="#meta">Metaprogramming and type traits</a>
        
          <ol>
            
              <li><span class="marker">3.3.1</span><a href="#meta.type.synop">Header &lt;experimental/type_traits&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">3.3.2</span><a href="#meta.trans.other">Other type transformations</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">3.4</span><a href="#ratio">Compile-time rational arithmetic</a>
        
          <ol>
            
              <li><span class="marker">3.4.1</span><a href="#header.ratio.synop">Header &lt;experimental/ratio&gt; synopsis</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">3.5</span><a href="#time">Time utilities</a>
        
          <ol>
            
              <li><span class="marker">3.5.1</span><a href="#header.chrono.synop">Header &lt;experimental/chrono&gt; synopsis</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">3.6</span><a href="#syserror">System error support</a>
        
          <ol>
            
              <li><span class="marker">3.6.1</span><a href="#header.system_error.synop">Header &lt;experimental/system_error&gt; synopsis</a>
        
      </li>
            
          </ol>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">4</span><a href="#func">Function objects</a>
        
          <ol>
            
              <li><span class="marker">4.1</span><a href="#header.functional.synop">Header &lt;experimental/functional&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">4.2</span><a href="#func.wrap.func">Class template function</a>
        
          <ol>
            
              <li><span class="marker">4.2.1</span><a href="#func.wrap.func.con">function construct/copy/destroy</a>
        
      </li>
            
              <li><span class="marker">4.2.2</span><a href="#func.wrap.func.mod">function modifiers</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">4.3</span><a href="#func.searchers">Searchers</a>
        
          <ol>
            
              <li><span class="marker">4.3.1</span><a href="#func.searchers.default">Class template default_searcher</a>
        
          <ol>
            
              <li><span class="marker">4.3.1.1</span><a href="#func.searchers.default.creation">default_searcher creation functions</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">4.3.2</span><a href="#func.searchers.boyer_moore">Class template boyer_moore_searcher</a>
        
          <ol>
            
              <li><span class="marker">4.3.2.1</span><a href="#func.searchers.boyer_moore.creation">boyer_moore_searcher creation functions</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">4.3.3</span><a href="#func.searchers.boyer_moore_horspool">Class template boyer_moore_horspool_searcher</a>
        
          <ol>
            
              <li><span class="marker">4.3.3.1</span><a href="#func.searchers.boyer_moore_horspool.creation">boyer_moore_horspool_searcher creation functions</a>
        
      </li>
            
          </ol>
        
      </li>
            
          </ol>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">5</span><a href="#optional">Optional objects</a>
        
          <ol>
            
              <li><span class="marker">5.1</span><a href="#optional.general">In general</a>
        
      </li>
            
              <li><span class="marker">5.2</span><a href="#optional.synop">Header &lt;experimental/optional&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">5.3</span><a href="#optional.object">optional for object types</a>
        
          <ol>
            
              <li><span class="marker">5.3.1</span><a href="#optional.object.ctor">Constructors</a>
        
      </li>
            
              <li><span class="marker">5.3.2</span><a href="#optional.object.dtor">Destructor</a>
        
      </li>
            
              <li><span class="marker">5.3.3</span><a href="#optional.object.assign">Assignment</a>
        
      </li>
            
              <li><span class="marker">5.3.4</span><a href="#optional.object.swap">Swap</a>
        
      </li>
            
              <li><span class="marker">5.3.5</span><a href="#optional.object.observe">Observers</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">5.4</span><a href="#optional.inplace">In-place construction</a>
        
      </li>
            
              <li><span class="marker">5.5</span><a href="#optional.nullopt">No-value state indicator</a>
        
      </li>
            
              <li><span class="marker">5.6</span><a href="#optional.bad_optional_access">Class bad_optional_access</a>
        
      </li>
            
              <li><span class="marker">5.7</span><a href="#optional.relops">Relational operators</a>
        
      </li>
            
              <li><span class="marker">5.8</span><a href="#optional.nullops">Comparison with nullopt</a>
        
      </li>
            
              <li><span class="marker">5.9</span><a href="#optional.comp_with_t">Comparison with T</a>
        
      </li>
            
              <li><span class="marker">5.10</span><a href="#optional.specalg">Specialized algorithms</a>
        
      </li>
            
              <li><span class="marker">5.11</span><a href="#optional.hash">Hash support</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">6</span><a href="#any">Class any</a>
        
          <ol>
            
              <li><span class="marker">6.1</span><a href="#any.synop">Header &lt;experimental/any&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">6.2</span><a href="#any.bad_any_cast">Class bad_any_cast</a>
        
      </li>
            
              <li><span class="marker">6.3</span><a href="#any.class">Class any</a>
        
          <ol>
            
              <li><span class="marker">6.3.1</span><a href="#any.cons">any construct/destruct</a>
        
      </li>
            
              <li><span class="marker">6.3.2</span><a href="#any.assign">any assignments</a>
        
      </li>
            
              <li><span class="marker">6.3.3</span><a href="#any.modifiers">any modifiers</a>
        
      </li>
            
              <li><span class="marker">6.3.4</span><a href="#any.observers">any observers</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">6.4</span><a href="#any.nonmembers">Non-member functions</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">7</span><a href="#string.view">string_view</a>
        
          <ol>
            
              <li><span class="marker">7.1</span><a href="#string.view.synop">Header &lt;experimental/string_view&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">7.2</span><a href="#string.view.template">Class template basic_string_view</a>
        
      </li>
            
              <li><span class="marker">7.3</span><a href="#string.view.cons">basic_string_view constructors and assignment operators</a>
        
      </li>
            
              <li><span class="marker">7.4</span><a href="#string.view.iterators">basic_string_view iterator support</a>
        
      </li>
            
              <li><span class="marker">7.5</span><a href="#string.view.capacity">basic_string_view capacity</a>
        
      </li>
            
              <li><span class="marker">7.6</span><a href="#string.view.access">basic_string_view element access</a>
        
      </li>
            
              <li><span class="marker">7.7</span><a href="#string.view.modifiers">basic_string_view modifiers</a>
        
      </li>
            
              <li><span class="marker">7.8</span><a href="#string.view.ops">basic_string_view string operations</a>
        
          <ol>
            
              <li><span class="marker">7.8.1</span><a href="#string.view.find">Searching basic_string_view</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">7.9</span><a href="#string.view.comparison">basic_string_view non-member comparison functions</a>
        
      </li>
            
              <li><span class="marker">7.10</span><a href="#string.view.io">Inserters and extractors</a>
        
      </li>
            
              <li><span class="marker">7.11</span><a href="#string.view.hash">Hash support</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8</span><a href="#memory">Memory</a>
        
          <ol>
            
              <li><span class="marker">8.1</span><a href="#header.memory.synop">Header &lt;experimental/memory&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.2</span><a href="#memory.smartptr">Shared-ownership pointers</a>
        
          <ol>
            
              <li><span class="marker">8.2.1</span><a href="#memory.smartptr.shared">Class template shared_ptr</a>
        
          <ol>
            
              <li><span class="marker">8.2.1.1</span><a href="#memory.smartptr.shared.const">shared_ptr constructors</a>
        
      </li>
            
              <li><span class="marker">8.2.1.2</span><a href="#memory.smartptr.shared.obs">shared_ptr observers</a>
        
      </li>
            
              <li><span class="marker">8.2.1.3</span><a href="#memory.smartptr.shared.cast">shared_ptr casts</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.2.2</span><a href="#memory.smartptr.weak">Class template weak_ptr</a>
        
          <ol>
            
              <li><span class="marker">8.2.2.1</span><a href="#memory.smartptr.weak.const">weak_ptr constructors</a>
        
      </li>
            
          </ol>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.3</span><a href="#memory.type.erased.allocator">Type-erased allocator</a>
        
      </li>
            
              <li><span class="marker">8.4</span><a href="#memory.resource.synop">Header &lt;experimental/memory_resource&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.5</span><a href="#memory.resource">Class memory_resource</a>
        
          <ol>
            
              <li><span class="marker">8.5.1</span><a href="#memory.resource.overview">Class memory_resource overview</a>
        
      </li>
            
              <li><span class="marker">8.5.2</span><a href="#memory.resource.public">memory_resource public member functions</a>
        
      </li>
            
              <li><span class="marker">8.5.3</span><a href="#memory.resource.priv">memory_resource protected virtual member functions</a>
        
      </li>
            
              <li><span class="marker">8.5.4</span><a href="#memory.resource.eq">memory_resource equality</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.6</span><a href="#memory.polymorphic.allocator.class">Class template polymorphic_allocator</a>
        
          <ol>
            
              <li><span class="marker">8.6.1</span><a href="#memory.polymorphic.allocator.overview">Class template polymorphic_allocator overview</a>
        
      </li>
            
              <li><span class="marker">8.6.2</span><a href="#memory.polymorphic.allocator.ctor">polymorphic_allocator constructors</a>
        
      </li>
            
              <li><span class="marker">8.6.3</span><a href="#memory.polymorphic.allocator.mem">polymorphic_allocator member functions</a>
        
      </li>
            
              <li><span class="marker">8.6.4</span><a href="#memory.polymorphic.allocator.eq">polymorphic_allocator equality</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.7</span><a href="#memory.resource.adaptor">template alias resource_adaptor</a>
        
          <ol>
            
              <li><span class="marker">8.7.1</span><a href="#memory.resource.adaptor.overview">resource_adaptor</a>
        
      </li>
            
              <li><span class="marker">8.7.2</span><a href="#memory.resource.adaptor.ctor">resource_adaptor_imp constructors</a>
        
      </li>
            
              <li><span class="marker">8.7.3</span><a href="#memory.resource.adaptor.mem">resource_adaptor_imp member functions</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.8</span><a href="#memory.resource.global">Access to program-wide memory_resource objects</a>
        
      </li>
            
              <li><span class="marker">8.9</span><a href="#memory.resource.pool">Pool resource classes</a>
        
          <ol>
            
              <li><span class="marker">8.9.1</span><a href="#memory.resource.pool.overview">Classes synchronized_pool_resource and unsynchronized_pool_resource</a>
        
      </li>
            
              <li><span class="marker">8.9.2</span><a href="#memory.resource.pool.options">pool_options data members</a>
        
      </li>
            
              <li><span class="marker">8.9.3</span><a href="#memory.resource.pool.ctor">pool resource constructors and destructors</a>
        
      </li>
            
              <li><span class="marker">8.9.4</span><a href="#memory.resource.pool.mem">pool resource members</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.10</span><a href="#memory.resource.monotonic.buffer">Class monotonic_buffer_resource</a>
        
          <ol>
            
              <li><span class="marker">8.10.1</span><a href="#memory.resource.monotonic.buffer.overview">Class monotonic_buffer_resource overview</a>
        
      </li>
            
              <li><span class="marker">8.10.2</span><a href="#memory.resource.monotonic.buffer.ctor">monotonic_buffer_resource constructor and destructor</a>
        
      </li>
            
              <li><span class="marker">8.10.3</span><a href="#memory.resource.monotonic.buffer.mem">monotonic_buffer_resource members</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">8.11</span><a href="#memory.resource.aliases">Alias templates using polymorphic memory resources</a>
        
          <ol>
            
              <li><span class="marker">8.11.1</span><a href="#header.string.synop">Header &lt;experimental/string&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.2</span><a href="#header.deque.synop">Header &lt;experimental/deque&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.3</span><a href="#header.forward_list.synop">Header &lt;experimental/forward_list&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.4</span><a href="#header.list.synop">Header &lt;experimental/list&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.5</span><a href="#header.vector.synop">Header &lt;experimental/vector&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.6</span><a href="#header.map.synop">Header &lt;experimental/map&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.7</span><a href="#header.set.synop">Header &lt;experimental/set&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.8</span><a href="#header.unordered_map.synop">Header &lt;experimental/unordered_map&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.9</span><a href="#header.unordered_set.synop">Header &lt;experimental/unordered_set&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">8.11.10</span><a href="#header.regex.synop">Header &lt;experimental/regex&gt; synopsis</a>
        
      </li>
            
          </ol>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">9</span><a href="#futures">Futures</a>
        
          <ol>
            
              <li><span class="marker">9.1</span><a href="#header.future.synop">Header &lt;experimental/future&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">9.2</span><a href="#futures.promise">Class template promise</a>
        
      </li>
            
              <li><span class="marker">9.3</span><a href="#futures.task">Class template packaged_task</a>
        
      </li>
            
          </ol>
        
      </li>
            
              <li><span class="marker">10</span><a href="#algorithms">Algorithms library</a>
        
          <ol>
            
              <li><span class="marker">10.1</span><a href="#header.algorithm.synop">Header &lt;experimental/algorithm&gt; synopsis</a>
        
      </li>
            
              <li><span class="marker">10.2</span><a href="#alg.search">Search</a>
        
      </li>
            
              <li><span class="marker">10.3</span><a href="#alg.random.sample">Shufﬂing and sampling</a>
        
      </li>
            
          </ol>
        
      </li>
            
          </ol>
        
      
    </nav>
  </cxx-toc>

<cxx-clause id="general">
    

    <section>
      <header><span class="section-number">1</span> <h1 data-bookmark-label="1 General">General</h1> <span style="float:right"><a href="#general">[general]</a></span></header>
      
  
  <cxx-section id="general.scope">
    

    <section>
      <header><span class="section-number">1.1</span> <h1 data-bookmark-label="1.1 Scope">Scope</h1> <span style="float:right"><a href="#general.scope">[general.scope]</a></span></header>
      
    
    <p para_num="1" id="general.scope.1">This technical specification describes extensions to the C++
    Standard Library (<cxx-ref to="general.references"><a title="general.references" href="#general.references">1.2</a></cxx-ref>). These extensions are classes
    and functions that are likely to be used widely within a program
    and/or on the interface boundaries between libraries written by
    different organizations.</p>

    <p para_num="2" id="general.scope.2">This technical specification is non-normative. Some of the
    library components in this technical specification may be
    considered for standardization in a future version of C++, but
    they are not currently part of any C++ standard. Some of the
    components in this technical specification may never be
    standardized, and others may be standardized in a substantially
    changed form.</p>

    <p para_num="3" id="general.scope.3">The goal of this technical specification is to build more
    widespread existing practice for an expanded C++ standard
    library. It gives advice on extensions to those vendors who wish
    to provide them.</p>
  
    </section>
  </cxx-section>

  <cxx-section id="general.references">
    

    <section>
      <header><span class="section-number">1.2</span> <h1 data-bookmark-label="1.2 Normative references">Normative references</h1> <span style="float:right"><a href="#general.references">[general.references]</a></span></header>
      
    

    <p para_num="1" id="general.references.1">The following referenced document is indispensable for the
    application of this document. For dated references, only the
    edition cited applies. For undated references, the latest edition
    of the referenced document (including any amendments) applies.</p>

    <ul>
      <li>ISO/IEC 14882:2014, <cite>Programming Languages — C++</cite>
      </li>
    </ul>

    <p para_num="2" id="general.references.2">ISO/IEC 14882:— is herein called the <dfn>C++ Standard</dfn>.
    References to clauses within the C++ Standard are written as "C++14
    §3.2". The library described in ISO/IEC 14882:— clauses 17–30 is
    herein called the <dfn>C++ Standard Library</dfn>.</p>

    <p para_num="3" id="general.references.3">Unless otherwise specified, the whole of the C++ Standard's Library
    introduction (<cxx-ref in="cxx" to="library">C++14 <span title="library">§17</span></cxx-ref>) is included into this
    Technical Specification by reference.</p>
  
    </section>
  </cxx-section>

  <cxx-section id="general.namespaces">
    

    <section>
      <header><span class="section-number">1.3</span> <h1 data-bookmark-label="1.3 Namespaces, headers, and modifications to standard classes">Namespaces, headers, and modifications to standard classes</h1> <span style="float:right"><a href="#general.namespaces">[general.namespaces]</a></span></header>
      
    

    <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> This section reflects the consensus between the LWG and LEWG at the
    <a href="http://wiki.edg.com/twiki/bin/view/Wg21chicago2013/FundamentalsTS#What_can_go_into_a_TS">Chicago 2013</a> and
    <a href="http://wiki.edg.com/twiki/bin/view/Wg21issaquah/ChangesToExistingInTS">Issaquah 2014</a> meetings.</aside>
  </cxx-ednote>

    <p para_num="1" id="general.namespaces.1">Since the extensions described in this technical specification
    are experimental and not part of the C++ standard library, they
    should not be declared directly within namespace
    <code>std</code>.
    Unless otherwise specified, all components described in this technical specification either:
    </p>
    <ul>
      <li>modify an existing interface in the C++ Standard Library in-place,</li>
      <li>
        are declared in a namespace whose name appends <code>::experimental::fundamentals_v1</code>
        to a namespace defined in the C++ Standard Library,
        such as <code>std</code> or <code>std::chrono</code>, or
      </li>
      <li>
        are declared in a subnamespace of a namespace described in the previous bullet,
        whose name is not the same as an existing subnamespace of namespace <code>std</code>.
      </li>
    </ul>

    <cxx-example>
    
    <span class="nowrap">[ <em>Example:</em></span>
    
      This TS does not define <code>std::experimental::fundamentals_v1::chrono</code>
      because the C++ Standard Library defines <code>std::chrono</code>.
      This TS does not define <code>std::pmr::experimental::fundamentals_v1</code>
      because the C++ Standard Library does not define <code>std::pmr</code>.
    
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>

    <p para_num="2" id="general.namespaces.2">Each header described in this technical
    specification shall import the contents of
    <code>std::experimental::fundamentals_v1</code> into
    <code>std::experimental</code> as if by</p>

    <pre><code>namespace std {
  namespace experimental {
    inline namespace fundamentals_v1 {}
  }
}</code></pre>

    <p para_num="3" id="general.namespaces.3">
      This technical specification also describes some experimental modifications to existing interfaces in the C++ Standard Library.
      These modifications are described by quoting the affected parts of the standard
      and using <ins>underlining</ins> to represent added text and <del>strike-through</del> to represent deleted text.
    </p>

    <p para_num="4" id="general.namespaces.4">Unless otherwise specified, references to other entities
    described in this technical specification are assumed to be
    qualified with <code>std::experimental::fundamentals_v1::</code>,
    and references to entities described in the standard are assumed
    to be qualified with <code>std::</code>.</p>

    <p para_num="5" id="general.namespaces.5">Extensions that are expected to eventually be added to an
    existing header <code>&lt;meow&gt;</code> are provided inside the
    <code>&lt;experimental/meow&gt;</code> header, which shall include
    the standard contents of <code>&lt;meow&gt;</code> as if by</p>
    <pre><code>#include &lt;meow&gt;</code></pre>

    <p para_num="6" id="general.namespaces.6">New headers are also provided in the
    <code>&lt;experimental/&gt;</code> directory, but without such an
    <code>#include</code>.</p>

    <table role="presentation" is="cxx-table" id="tab.cxx.headers" class="list" columns="3">
    

    <caption>Table 1 — <wbr><span>C++ library headers</span></caption>
    
      
      <tbody><tr><td><ul><li><code>&lt;experimental/algorithm&gt;</code></li><li><code>&lt;experimental/any&gt;</code></li><li><code>&lt;experimental/chrono&gt;</code></li><li><code>&lt;experimental/deque&gt;</code></li><li><code>&lt;experimental/forward_list&gt;</code></li><li><code>&lt;experimental/functional&gt;</code></li><li><code>&lt;experimental/future&gt;</code></li><li><code>&lt;experimental/list&gt;</code></li></ul></td><td><ul><li><code>&lt;experimental/map&gt;</code></li><li><code>&lt;experimental/memory&gt;</code></li><li><code>&lt;experimental/memory_resource&gt;</code></li><li><code>&lt;experimental/optional&gt;</code></li><li><code>&lt;experimental/ratio&gt;</code></li><li><code>&lt;experimental/regex&gt;</code></li><li><code>&lt;experimental/set&gt;</code></li><li><code>&lt;experimental/string&gt;</code></li></ul></td><td><ul><li><code>&lt;experimental/string_view&gt;</code></li><li><code>&lt;experimental/system_error&gt;</code></li><li><code>&lt;experimental/tuple&gt;</code></li><li><code>&lt;experimental/type_traits&gt;</code></li><li><code>&lt;experimental/unordered_map&gt;</code></li><li><code>&lt;experimental/unordered_set&gt;</code></li><li><code>&lt;experimental/utility&gt;</code></li><li><code>&lt;experimental/vector&gt;</code></li></ul></td></tr>
    </tbody>
  </table>
  
    </section>
  </cxx-section>

  <cxx-section id="general.defns">
    

    <section>
      <header><span class="section-number">1.4</span> <h1 data-bookmark-label="1.4 Terms and definitions">Terms and definitions</h1> <span style="float:right"><a href="#general.defns">[general.defns]</a></span></header>
      
    

    <p para_num="1" id="general.defns.1">For the purposes of this document, the terms and definitions
    given in the C++ Standard and the following apply.</p>

    <dl is="cxx-definition-section">
    

    
      <dt id="general.defns.direct-non-list-init">
    1.4.1
    <span style="float:right"><a href="#general.defns.direct-non-list-init">[general.defns.direct-non-list-init]</a></span>
    <br clear="all">
    direct-non-list-initialization
  </dt>
      <dd>A direct-initialization that is not list-initialization.</dd>
    
  </dl>
  
    </section>
  </cxx-section>

  <cxx-section id="general.plans">
    

    <section>
      <header><span class="section-number">1.5</span> <h1 data-bookmark-label="1.5 Future plans (Informative)">Future plans (Informative)</h1> <span style="float:right"><a href="#general.plans">[general.plans]</a></span></header>
      
    

    <p para_num="1" id="general.plans.1">This section describes tentative plans for future versions of
    this technical specification and plans for moving content into
    future versions of the C++ Standard.</p>

    <p para_num="2" id="general.plans.2">The C++ committee intends to release a new version of this
    technical specification approximately every year, containing the
    library extensions we hope to add to a near-future version of the
    C++ Standard.  Future versions will define their contents in
    <code>std::experimental::fundamentals_v2</code>,
    <code>std::experimental::fundamentals_v3</code>, etc., with the
    most recent implemented version inlined into
    <code>std::experimental</code>.</p>

    <p para_num="3" id="general.plans.3">When an extension defined in this or a future version of this
    technical specification represents enough existing practice, it
    will be moved into the next version of the C++ Standard by
    removing the <code>experimental::fundamentals_v<var>N</var></code>
    segment of its namespace and by removing the
    <code>experimental/</code> prefix from its header's path.</p>
  
    </section>
  </cxx-section>

  <cxx-section id="general.feature.test">
    

    <section>
      <header><span class="section-number">1.6</span> <h1 data-bookmark-label="1.6 Feature-testing recommendations (Informative)">Feature-testing recommendations (Informative)</h1> <span style="float:right"><a href="#general.feature.test">[general.feature.test]</a></span></header>
      
    

    <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> 
      These feature-testing macros are my invention, with very little input from anyone else.
      I've tried to be consistent with the SD-6 recommendations and
      divide features where I suspect they may be implemented at different times despite being added by the same paper.
      I'll be happy to accept changes to this section as editorial fixes until the PDTS is published.
    </aside>
  </cxx-ednote>

    <p para_num="1" id="general.feature.test.1">
      For the sake of improved portability between partial implementations of various C++ standards,
      WG21 (the ISO technical committee for the C++ programming language) recommends
      that implementers and programmers follow the guidelines in this section concerning feature-test macros.
      <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    <a href="http://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations">WG21's SD-6</a> makes similar recommendations for the C++ Standard itself.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
    </p>

    <p para_num="2" id="general.feature.test.2">
      Implementers who provide a new standard feature should define a macro with the recommended name,
      in the same circumstances under which the feature is available (for example, taking into account relevant command-line options),
      to indicate the presence of support for that feature.
      Implementers should define that macro with the value specified in
      the most recent version of this technical specification that they have implemented.
      The recommended macro name is "<code>__cpp_lib_experimental_</code>" followed by the string in the "Macro Name Suffix" column.
    </p>

    <p para_num="3" id="general.feature.test.3">
      Programmers who wish to determine whether a feature is available in an implementation should base that determination on
      the presence of the header (determined with <code>__has_include(&lt;header/name&gt;)</code>) and
      the state of the macro with the recommended name.
      (The absence of a tested feature may result in a program with decreased functionality, or the relevant functionality may be provided in a different way.
      A program that strictly depends on support for a feature can just try to use the feature unconditionally;
      presumably, on an implementation lacking necessary support, translation will fail.)
    </p>

    <table is="cxx-table" class="column-rules">
    

    <caption>Table 2 — <wbr><span>Significant features in this technical specification</span></caption>
    
      

      <thead>
        <tr>
          <th>Doc. No.</th>
          <th>Title</th>
          <th>Primary Section</th>
          <th>Macro Name Suffix</th>
          <th>Value</th>
          <th>Header</th>
        </tr>
      </thead>

      <!-- These rows are in the same order as their feature appears in this document. -->
      <tbody><tr>
        <td>N3915</td>
        <td>apply() call a function with arguments from a tuple</td>
        <td><cxx-ref to="tuple.apply"><a title="tuple.apply" href="#tuple.apply">3.2.2</a></cxx-ref></td>
        <td><code>apply</code></td>
        <td>201402</td>
        <td><code>&lt;experimental/tuple&gt;</code></td>
      </tr>
      <tr>
        <td>N3932</td>
        <td>Variable Templates For Type Traits</td>
        <td><cxx-ref to="meta.type.synop"><a title="meta.type.synop" href="#meta.type.synop">3.3.1</a></cxx-ref></td>
        <td><code>type_trait_variable_templates</code></td>
        <td>201402</td>
        <td><code>&lt;experimental/type_traits&gt;</code></td>
      </tr>
      <tr>
        <td>N3866</td>
        <td>Invocation type traits</td>
        <td><cxx-ref to="meta.trans.other"><a title="meta.trans.other" href="#meta.trans.other">3.3.2</a></cxx-ref></td>
        <td><code>invocation_type</code></td>
        <td>201406</td>
        <td><code>&lt;experimental/type_traits&gt;</code></td>
      </tr>
      <tr>
        <td>N3916</td>
        <td>Type-erased allocator for std::function</td>
        <td><cxx-ref to="func.wrap.func"><a title="func.wrap.func" href="#func.wrap.func">4.2</a></cxx-ref></td>
        <td><code>function_erased_allocator</code></td>
        <td>201406</td>
        <td><code>&lt;experimental/functional&gt;</code></td>
      </tr>
      <tr>
        <td>N3905</td>
        <td>Extending <code>std::search</code> to use Additional Searching Algorithms</td>
        <td><cxx-ref to="func.searchers"><a title="func.searchers" href="#func.searchers">4.3</a></cxx-ref></td>
        <td><code>boyer_moore_searching</code></td>
        <td>201411</td>
        <td><code>&lt;experimental/functional&gt;</code></td>
      </tr>
      <tr>
        <td>N3672, N3793</td>
        <td>A utility class to represent optional objects</td>
        <td><cxx-ref to="optional"><a title="optional" href="#optional">5</a></cxx-ref></td>
        <td><code>optional</code></td>
        <td>201411</td>
        <td><code>&lt;experimental/optional&gt;</code></td>
      </tr>
      <tr>
        <td>N3804</td>
        <td>Any Library Proposal</td>
        <td><cxx-ref to="any"><a title="any" href="#any">6</a></cxx-ref></td>
        <td><code>any</code></td>
        <td>201411</td>
        <td><code>&lt;experimental/any&gt;</code></td>
      </tr>
      <tr>
        <td>N3921</td>
        <td><code>string_view</code>: a non-owning reference to a string</td>
        <td><cxx-ref to="string.view"><a title="string.view" href="#string.view">7</a></cxx-ref></td>
        <td><code>string_view</code></td>
        <td>201411</td>
        <td><code>&lt;experimental/string_view&gt;</code></td>
      </tr>
      <tr>
        <td>N3920</td>
        <td>Extending shared_ptr to Support Arrays</td>
        <td><cxx-ref to="memory.smartptr"><a title="memory.smartptr" href="#memory.smartptr">8.2</a></cxx-ref></td>
        <td><code>shared_ptr_arrays</code></td>
        <td>201406</td>
        <td><code>&lt;experimental/memory&gt;</code></td>
      </tr>
      <tr>
        <td>N3916</td>
        <td>Polymorphic Memory Resources</td>
        <td><cxx-ref to="memory.resource.synop"><a title="memory.resource.synop" href="#memory.resource.synop">8.4</a></cxx-ref></td>
        <td><code>memory_resources</code></td>
        <td>201402</td>
        <td><code>&lt;experimental/memory_resource&gt;</code></td>
      </tr>
      <tr>
        <td>N3916</td>
        <td>Type-erased allocator for std::promise</td>
        <td><cxx-ref to="futures.promise"><a title="futures.promise" href="#futures.promise">9.2</a></cxx-ref></td>
        <td><code>promise_erased_allocator</code></td>
        <td>201406</td>
        <td><code>&lt;experimental/future&gt;</code></td>
      </tr>
      <tr>
        <td>N3916</td>
        <td>Type-erased allocator for std::packaged_task</td>
        <td><cxx-ref to="futures.task"><a title="futures.task" href="#futures.task">9.3</a></cxx-ref></td>
        <td><code>packaged_task_erased_allocator</code></td>
        <td>201406</td>
        <td><code>&lt;experimental/future&gt;</code></td>
      </tr>
      <tr>
        <td>N3925</td>
        <td>A <code>sample</code> Proposal</td>
        <td><cxx-ref to="alg.random.sample"><a title="alg.random.sample" href="#alg.random.sample">10.3</a></cxx-ref></td>
        <td><code>sample</code></td>
        <td>201402</td>
        <td><code>&lt;experimental/algorithm&gt;</code></td>
      </tr>
    </tbody>
  </table>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="mods">
    

    <section>
      <header><span class="section-number">2</span> <h1 data-bookmark-label="2 Modifications to the C++ Standard Library">Modifications to the C++ Standard Library</h1> <span style="float:right"><a href="#mods">[mods]</a></span></header>
      
  

  <p para_num="1" id="mods.1">
    Implementations that conform to this technical specification shall
    behave as if the modifications contained in this section are made to the C++ Standard.
  </p>

  <cxx-section id="mods.allocator.uses">
    

    <section>
      <header><span class="section-number">2.1</span> <h1 data-bookmark-label="2.1 Uses-allocator construction">Uses-allocator construction</h1> <span style="float:right"><a href="#mods.allocator.uses">[mods.allocator.uses]</a></span></header>
      
    

    <p para_num="1" id="mods.allocator.uses.1">
      The following changes to the <code>uses_allocator</code> trait and to the description of uses-allocator construction
      allow a <code>memory_resource</code> pointer act as an allocator in many circumstances.
      <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    Existing programs that use standard allocators would be unaffected by this change.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
    </p>

    <blockquote>
      <p><b>20.7.7 uses_allocator [allocator.uses]</b></p>
      <p><b>20.7.7.1 uses_allocator trait [allocator.uses.trait]</b></p>

      <cxx-function>
    
    <pre><code><cxx-signature>template &lt;class T, class Alloc&gt; struct uses_allocator;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-remarks>
    
    <dt>Remarks:</dt><dd>
          automatically detects whether <code>T</code> has a nested <code>allocator_type</code> that is convertible from <code>Alloc</code>.
          Meets the BinaryTypeTrait requirements (<cxx-ref in="cxx" to="meta.rqmts">C++14 <span title="meta.rqmts">§20.10.1</span></cxx-ref>).
          The implementation shall provide a definition that is derived from <code>true_type</code> if a type <code>T::allocator_type</code> exists
          and <ins>either</ins> <code>is_convertible_v&lt;Alloc, T::allocator_type&gt; != false</code>
          <ins>or <code>T::allocator_type</code> is an alias for <code>std::experimental::erased_type</code> (<cxx-ref to="utility.erased.type"><a title="utility.erased.type" href="#utility.erased.type">3.1.2</a></cxx-ref>)</ins>,
          otherwise it shall be derived from <code>false_type</code>.
          A program may specialize this template to derive from <code>true_type</code> for a user-defined type <code>T</code> that does not have a nested <code>allocator_type</code> but nonetheless can be constructed with an allocator where either:
          <ul>
            <li>the first argument of a constructor has type <code>allocator_arg_t</code> and the second argument has type <code>Alloc</code> or</li>
            <li>the last argument of a constructor has type <code>Alloc</code>.</li>
          </ul>
        </dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <p><b>20.7.7.2 uses-allocator construction [allocator.uses.construction]</b></p>

      <p>
        <dfn>Uses-allocator construction</dfn> with allocator <code>Alloc</code> refers to the construction of an object <code>obj</code> of type <code>T</code>,
        using constructor arguments <code>v1, v2, ..., vN</code> of types <code>V1, V2, ..., VN</code>, respectively,
        and an allocator <code>alloc</code> of type <code>Alloc</code>,
        <ins>where <code>Alloc</code> either (1) meets the requirements of an allocator (<cxx-ref in="cxx" to="allocator.requirements">C++14 <span title="allocator.requirements">§17.6.3.5</span></cxx-ref>),
        or (2) is a pointer type convertible to <code>std::experimental::pmr::memory_resource*</code> (<cxx-ref to="memory.resource"><a title="memory.resource" href="#memory.resource">8.5</a></cxx-ref>),</ins>
        according to the following rules:
      </p>
    </blockquote>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="utilities">
    

    <section>
      <header><span class="section-number">3</span> <h1 data-bookmark-label="3 General utilities library">General utilities library</h1> <span style="float:right"><a href="#utilities">[utilities]</a></span></header>
      
  

  <cxx-section id="utility">
    

    <section>
      <header><span class="section-number">3.1</span> <h1 data-bookmark-label="3.1 Utility components">Utility components</h1> <span style="float:right"><a href="#utility">[utility]</a></span></header>
      
    

    <cxx-section id="utility.synop">
    

    <section>
      <header><span class="section-number">3.1.1</span> <h1 data-bookmark-label="3.1.1 Header <experimental/utility> synopsis">Header <code>&lt;experimental/utility&gt;</code> synopsis</h1> <span style="float:right"><a href="#utility.synop">[utility.synop]</a></span></header>
      
      

<pre><code>#include &lt;utility&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  <cxx-ref to="utility.erased.type"><a title="utility.erased.type" href="#utility.erased.type">3.1.2</a></cxx-ref>, erased-type placeholder
  struct erased_type { };

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>

    
    </section>
  </cxx-section>

    <cxx-section id="utility.erased.type">
    

    <section>
      <header><span class="section-number">3.1.2</span> <h1 data-bookmark-label="3.1.2 Class erased_type">Class <code>erased_type</code></h1> <span style="float:right"><a href="#utility.erased.type">[utility.erased.type]</a></span></header>
      
      

      <cxx-function para_num="1" id="utility.erased.type.1">
    
    <pre><code><cxx-signature>struct erased_type { };</cxx-signature></code></pre>

    <dl>
      
        

        <p para_num="2" id="utility.erased.type.2">
          The <code>erased_type</code> <code>struct</code> is an empty <code>struct</code> that serves as a placeholder for a type <code>T</code> in situations where the actual type <code>T</code> is determined at runtime.
          For example, the nested type, <code>allocator_type</code>, is an alias for <code>erased_type</code> in classes that use <i>type-erased allocators</i> (see <cxx-ref to="memory.type.erased.allocator"><a title="memory.type.erased.allocator" href="#memory.type.erased.allocator">8.3</a></cxx-ref>).
        </p>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="tuple">
    

    <section>
      <header><span class="section-number">3.2</span> <h1 data-bookmark-label="3.2 Tuples">Tuples</h1> <span style="float:right"><a href="#tuple">[tuple]</a></span></header>
      
    

    <cxx-section id="header.tuple.synop">
    

    <section>
      <header><span class="section-number">3.2.1</span> <h1 data-bookmark-label="3.2.1 Header <experimental/tuple> synopsis">Header &lt;experimental/tuple&gt; synopsis</h1> <span style="float:right"><a href="#header.tuple.synop">[header.tuple.synop]</a></span></header>
      
      

<pre><code>#include &lt;tuple&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  // See <cxx-ref in="cxx" to="tuple.helper">C++14 <span title="tuple.helper">§20.4.2.5</span></cxx-ref>, tuple helper classes
  template &lt;class T&gt; constexpr size_t tuple_size_v
    = tuple_size&lt;T&gt;::value;

  <cxx-ref insynopsis="" to="tuple.apply">// <i><a title="tuple.apply" href="#tuple.apply">3.2.2</a>, Calling a function with a tuple of arguments</i></cxx-ref>
  template &lt;class F, class Tuple&gt;
  constexpr decltype(auto) apply(F&amp;&amp; f, Tuple&amp;&amp; t);

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="tuple.apply">
    

    <section>
      <header><span class="section-number">3.2.2</span> <h1 data-bookmark-label="3.2.2 Calling a function with a tuple of arguments">Calling a function with a <code>tuple</code> of arguments</h1> <span style="float:right"><a href="#tuple.apply">[tuple.apply]</a></span></header>
      
      

      <cxx-function para_num="1" id="tuple.apply.1">
    
    <pre><code><cxx-signature>template &lt;class F, class Tuple&gt;
constexpr decltype(auto) apply(F&amp;&amp; f, Tuple&amp;&amp; t);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="tuple.apply.2">
    
    <dt>Effects:</dt><dd>
          <p>Given the exposition only function</p>
          <pre><code>template &lt;class F, class Tuple, size_t... I&gt;
constexpr decltype(auto) apply_impl(  // <i>exposition only</i>
    F&amp;&amp; f, Tuple&amp;&amp; t, index_sequence&lt;I...&gt;) {
  return std::forward&lt;F&gt;(f)(std::get&lt;I&gt;(std::forward&lt;Tuple&gt;(t))...);
}</code></pre>
          <p>Equivalent to</p>
          <pre><code>return apply_impl(std::forward&lt;F&gt;(f), std::forward&lt;Tuple&gt;(t),
    make_index_sequence&lt;tuple_size_v&lt;decay_t&lt;Tuple&gt;&gt;&gt;{});</code></pre>
        </dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="meta">
    

    <section>
      <header><span class="section-number">3.3</span> <h1 data-bookmark-label="3.3 Metaprogramming and type traits">Metaprogramming and type traits</h1> <span style="float:right"><a href="#meta">[meta]</a></span></header>
      
    

    <cxx-section id="meta.type.synop">
    

    <section>
      <header><span class="section-number">3.3.1</span> <h1 data-bookmark-label="3.3.1 Header <experimental/type_traits> synopsis">Header &lt;experimental/type_traits&gt; synopsis</h1> <span style="float:right"><a href="#meta.type.synop">[meta.type.synop]</a></span></header>
      
      

<pre><code>#include &lt;type_traits&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  // See <cxx-ref in="cxx" to="meta.unary.cat">C++14 <span title="meta.unary.cat">§20.10.4.1</span></cxx-ref>, primary type categories
  template &lt;class T&gt; constexpr bool is_void_v
    = is_void&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_null_pointer_v
    = is_null_pointer&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_integral_v
    = is_integral&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_floating_point_v
    = is_floating_point&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_array_v
    = is_array&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_pointer_v
    = is_pointer&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_lvalue_reference_v
    = is_lvalue_reference&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_rvalue_reference_v
    = is_rvalue_reference&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_member_object_pointer_v
    = is_member_object_pointer&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_member_function_pointer_v
    = is_member_function_pointer&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_enum_v
    = is_enum&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_union_v
    = is_union&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_class_v
    = is_class&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_function_v
    = is_function&lt;T&gt;::value;

  // See <cxx-ref in="cxx" to="meta.unary.comp">C++14 <span title="meta.unary.comp">§20.10.4.2</span></cxx-ref>, composite type categories
  template &lt;class T&gt; constexpr bool is_reference_v
    = is_reference&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_arithmetic_v
    = is_arithmetic&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_fundamental_v
    = is_fundamental&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_object_v
    = is_object&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_scalar_v
    = is_scalar&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_compound_v
    = is_compound&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_member_pointer_v
    = is_member_pointer&lt;T&gt;::value;

  // See <cxx-ref in="cxx" to="meta.unary.prop">C++14 <span title="meta.unary.prop">§20.10.4.3</span></cxx-ref>, type properties
  template &lt;class T&gt; constexpr bool is_const_v
    = is_const&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_volatile_v
    = is_volatile&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivial_v
    = is_trivial&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_copyable_v
    = is_trivially_copyable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_standard_layout_v
    = is_standard_layout&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_pod_v
    = is_pod&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_literal_type_v
    = is_literal_type&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_empty_v
    = is_empty&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_polymorphic_v
    = is_polymorphic&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_abstract_v
    = is_abstract&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_final_v
    = is_final&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_signed_v
    = is_signed&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_unsigned_v
    = is_unsigned&lt;T&gt;::value;
  template &lt;class T, class... Args&gt; constexpr bool is_constructible_v
    = is_constructible&lt;T, Args...&gt;::value;
  template &lt;class T&gt; constexpr bool is_default_constructible_v
    = is_default_constructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_copy_constructible_v
    = is_copy_constructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_move_constructible_v
    = is_move_constructible&lt;T&gt;::value;
  template &lt;class T, class U&gt; constexpr bool is_assignable_v
    = is_assignable&lt;T, U&gt;::value;
  template &lt;class T&gt; constexpr bool is_copy_assignable_v
    = is_copy_assignable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_move_assignable_v
    = is_move_assignable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_destructible_v
    = is_destructible&lt;T&gt;::value;
  template &lt;class T, class... Args&gt; constexpr bool is_trivially_constructible_v
    = is_trivially_constructible&lt;T, Args...&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_default_constructible_v
    = is_trivially_default_constructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_copy_constructible_v
    = is_trivially_copy_constructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_move_constructible_v
    = is_trivially_move_constructible&lt;T&gt;::value;
  template &lt;class T, class U&gt; constexpr bool is_trivially_assignable_v
    = is_trivially_assignable&lt;T, U&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_copy_assignable_v
    = is_trivially_copy_assignable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_move_assignable_v
    = is_trivially_move_assignable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_trivially_destructible_v
    = is_trivially_destructible&lt;T&gt;::value;
  template &lt;class T, class... Args&gt; constexpr bool is_nothrow_constructible_v
    = is_nothrow_constructible&lt;T, Args...&gt;::value;
  template &lt;class T&gt; constexpr bool is_nothrow_default_constructible_v
    = is_nothrow_default_constructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_nothrow_copy_constructible_v
    = is_nothrow_copy_constructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_nothrow_move_constructible_v
    = is_nothrow_move_constructible&lt;T&gt;::value;
  template &lt;class T, class U&gt; constexpr bool is_nothrow_assignable_v
    = is_nothrow_assignable&lt;T, U&gt;::value;
  template &lt;class T&gt; constexpr bool is_nothrow_copy_assignable_v
    = is_nothrow_copy_assignable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_nothrow_move_assignable_v
    = is_nothrow_move_assignable&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_nothrow_destructible_v
    = is_nothrow_destructible&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool has_virtual_destructor_v
    = has_virtual_destructor&lt;T&gt;::value;

  // See <cxx-ref in="cxx" to="meta.unary.prop.query">C++14 <span title="meta.unary.prop.query">§20.10.5</span></cxx-ref>, type property queries
  template &lt;class T&gt; constexpr size_t alignment_of_v
    = alignment_of&lt;T&gt;::value;
  template &lt;class T&gt; constexpr size_t rank_v
    = rank&lt;T&gt;::value;
  template &lt;class T, unsigned I = 0&gt; constexpr size_t extent_v
    = extent&lt;T, I&gt;::value;

  // See <cxx-ref in="cxx" to="meta.rel">C++14 <span title="meta.rel">§20.10.6</span></cxx-ref>, type relations
  template &lt;class T, class U&gt; constexpr bool is_same_v
    = is_same&lt;T, U&gt;::value;
  template &lt;class Base, class Derived&gt; constexpr bool is_base_of_v
    = is_base_of&lt;Base, Derived&gt;::value;
  template &lt;class From, class To&gt; constexpr bool is_convertible_v
    = is_convertible&lt;From, To&gt;::value;

  <cxx-ref insynopsis="" to="meta.trans.other">// <i><a title="meta.trans.other" href="#meta.trans.other">3.3.2</a>, Other type transformations</i></cxx-ref>
  template &lt;class&gt; class invocation_type; // <i>not defined</i>
  template &lt;class F, class... ArgTypes&gt; class invocation_type&lt;F(ArgTypes...)&gt;;
  template &lt;class&gt; class raw_invocation_type; // <i>not defined</i>
  template &lt;class F, class... ArgTypes&gt; class raw_invocation_type&lt;F(ArgTypes...)&gt;;

  template &lt;class T&gt;
    using invocation_type_t = typename invocation_type&lt;T&gt;::type;
  template &lt;class T&gt;
    using raw_invocation_type_t = typename raw_invocation_type&lt;T&gt;::type;

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>

    
    </section>
  </cxx-section>

    <cxx-section id="meta.trans.other">
    

    <section>
      <header><span class="section-number">3.3.2</span> <h1 data-bookmark-label="3.3.2 Other type transformations">Other type transformations</h1> <span style="float:right"><a href="#meta.trans.other">[meta.trans.other]</a></span></header>
      
      

      <p para_num="1" id="meta.trans.other.1">
        This sub-clause contains templates that may be used to transform one type to another following some predefined rule.
      </p>

      <p para_num="2" id="meta.trans.other.2">
        Each of the templates in this subclause shall be a <cxx-term><i>TransformationTrait</i></cxx-term> (<cxx-ref in="cxx" to="meta.rqmts">C++14 <span title="meta.rqmts">§20.10.1</span></cxx-ref>).
      </p>

      <p para_num="3" id="meta.trans.other.3">
        Within this section, define the <dfn>invocation parameters</dfn> of <code><em>INVOKE</em>(f, t1, t2, ..., tN)</code> as follows,
        in which <code>T1</code> is the possibly <var>cv</var>-qualified type of <code>t1</code>
        and <code>U1</code> denotes <code>T1&amp;</code> if <code>t1</code> is an lvalue
        or <code>T1&amp;&amp;</code> if <code>t1</code> is an rvalue:
      </p>
      <ul>
        <li>
          When <code>f</code> is a pointer to a member function of a class <code>T</code>
          the <cxx-term><i>invocation parameters</i></cxx-term> are <code>U1</code> followed by
          the parameters of <code>f</code> matched by <code>t2</code>, ..., <code>tN</code>.
        </li>
        <li>
          When <code>N == 1</code> and <code>f</code> is a pointer to member data of a class <code>T</code>
          the <cxx-term><i>invocation parameter</i></cxx-term> is <code>U1</code>.
        </li>
        <li>
          If <code>f</code> is a class object,
          the <cxx-term><i>invocation parameters</i></cxx-term> are the parameters matching <code>t1</code>, ..., <code>tN</code>
          of the best viable function (<cxx-ref in="cxx" to="over.match.best">C++14 <span title="over.match.best">§13.3.3</span></cxx-ref>)
          for the arguments <code>t1</code>, ..., <code>tN</code>
          among the function call operators of <code>f</code>.
        </li>
        <li>
          In all other cases,
          the <cxx-term><i>invocation parameters</i></cxx-term> are the parameters of <code>f</code>
          matching <code>t1</code>, ... <code>tN</code>.
        </li>
      </ul>
      <p para_num="4" id="meta.trans.other.4">
        In all of the above cases,
        if an argument <code>tI</code> matches the ellipsis in the function's <cxx-term><i>parameter-declaration-clause</i></cxx-term>,
        the corresponding <cxx-term><i>invocation parameter</i></cxx-term> is defined to be
        the result of applying the default argument promotions (<cxx-ref in="cxx" to="expr.call">C++14 <span title="expr.call">§5.2.2</span></cxx-ref>) to <code>tI</code>.
      </p>

      <cxx-example>
    
    <span class="nowrap">[ <em>Example:</em></span>
    
        Assume <code>S</code> is defined as
        <pre><code>struct S {
  int f(double const &amp;) const;
  void operator()(int, int);
  void operator()(char const *, int i = 2, int j = 3);
  void operator()(...);
};</code></pre>
        <ul>
          <li>The invocation parameters of <code><em>INVOKE</em>(&amp;S::f, S(), 3.5)</code> are <code>(S &amp;&amp;, double const &amp;)</code>.</li>
          <li>The invocation parameters of <code><em>INVOKE</em>(S(), 1, 2)</code> are <code>(int, int)</code>.</li>
          <li>The invocation parameters of <code><em>INVOKE</em>(S(), "abc", 5)</code> are <code>(const char *, int)</code>.
          The defaulted parameter <code>j</code> does not correspond to an argument.</li>
          <li>The invocation parameters of <code><em>INVOKE</em>(S(), locale(), 5)</code> are <code>(locale, int)</code>.
          Arguments corresponding to ellipsis maintain their types</li>
        </ul>
      
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>

      <table is="cxx-table" id="tab:meta.trans.other">
    

    <caption>Table 3 — <wbr><span>Other type transformations</span></caption>
    
        
        <thead>
          <tr><th>Template</th><th>Condition</th><th>Comments</th></tr>
        </thead>
        <tbody><tr>
          <td>
            <code>template &lt;class Fn, class... ArgTypes&gt;<br>
            struct raw_invocation_type&lt;<w-br><wbr></w-br>Fn(ArgTypes...)&gt;;</code>
          </td>
          <td>
            <code>Fn</code> and all types in the parameter pack <code>ArgTypes</code>
            shall be complete types, (possibly cv-qualified) <code>void</code>, or arrays of unknown bound.
          </td>

          <td>
            <em>see below</em>
          </td>
        </tr>
        <tr>
          <td>
            <code>template &lt;class Fn, class... ArgTypes&gt;<br>
            struct invocation_type&lt;<w-br><wbr></w-br>Fn(ArgTypes...)&gt;;</code>
          </td>
          <td>
            <code>Fn</code> and all types in the parameter pack <code>ArgTypes</code>
            shall be complete types, (possibly cv-qualified) <code>void</code>,
            or arrays of unknown bound.
          </td>
          <td>
            <em>see below</em>
          </td>
        </tr>
      </tbody>
  </table>

      <p para_num="5" id="meta.trans.other.5">
        Access checking is performed as if in a context unrelated to <code>Fn</code> and <code>ArgTypes</code>.
        Only the validity of the immediate context of the expression is considered.
        <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The compilation of the expression can result in side effects
        such as the instantiation of class template specializations and function template specializations,
        the generation of implicitly-defined functions, and so on.
        Such side effects are not in the "immediate context"
        and can result in the program being ill-formed.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
      </p>

      <p para_num="6" id="meta.trans.other.6">
        The nested typedef <code>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</code> shall be defined as follows.
        If the expression <code><em>INVOKE</em>(declval&lt;Fn&gt;(), declval&lt;ArgTypes&gt;()...)</code>
        is ill-formed when treated as an unevaluated operand (<cxx-ref in="cxx" to="expr">C++14 <span title="expr">§5</span></cxx-ref>),
        there shall be no member <code>type</code>. Otherwise:
      </p>
      <ul>
        <li>Let <code>R</code> denote <code>result_of_t&lt;Fn(ArgTypes...)&gt;</code>.</li>
        <li>Let the types <code>Ti</code> be the <cxx-term><i>invocation parameters</i></cxx-term>
        of <code><em>INVOKE</em>(declval&lt;Fn&gt;(), <nobr>declval&lt;ArgTypes&gt;()...)</nobr></code>.</li>
        <li>Then the member typedef <code>type</code> shall name the function type <code>R(T1, T2, ...)</code>.</li>
      </ul>

      <p para_num="7" id="meta.trans.other.7">
        The nested typedef <code>invocation_type&lt;Fn(ArgTypes...)&gt;::type</code> shall be defined as follows.
        If <code>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</code> does not exist, there shall be no member typedef <code>type</code>.
        Otherwise:
      </p>
      <ul>
        <li>Let <code>A1, A2,</code> … denote <code>ArgTypes...</code></li>
        <li>Let <code>R(T1, T2, …)</code> denote <code>raw_invocation_type_t&lt;Fn(ArgTypes...)&gt;</code></li>
        <li>
          Then the member typedef <code>type</code> shall name the function type <code>R(U1, U2, …)</code>
          where <code>Ui</code> is <code>decay_t&lt;Ai&gt;</code> if <code>declval&lt;Ai&gt;()</code> is an rvalue
          otherwise <code>Ti</code>.
        </li>
      </ul>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="ratio">
    

    <section>
      <header><span class="section-number">3.4</span> <h1 data-bookmark-label="3.4 Compile-time rational arithmetic">Compile-time rational arithmetic</h1> <span style="float:right"><a href="#ratio">[ratio]</a></span></header>
      
    

    <cxx-section id="header.ratio.synop">
    

    <section>
      <header><span class="section-number">3.4.1</span> <h1 data-bookmark-label="3.4.1 Header <experimental/ratio> synopsis">Header &lt;experimental/ratio&gt; synopsis</h1> <span style="float:right"><a href="#header.ratio.synop">[header.ratio.synop]</a></span></header>
      
      

<pre><code>#include &lt;ratio&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  // See <cxx-ref in="cxx" to="ratio.comparison">C++14 <span title="ratio.comparison">§20.11.5</span></cxx-ref>, ratio comparison
  template &lt;class R1, class R2&gt; constexpr bool ratio_equal_v
    = ratio_equal&lt;R1, R2&gt;::value;
  template &lt;class R1, class R2&gt; constexpr bool ratio_not_equal_v
    = ratio_not_equal&lt;R1, R2&gt;::value;
  template &lt;class R1, class R2&gt; constexpr bool ratio_less_v
    = ratio_less&lt;R1, R2&gt;::value;
  template &lt;class R1, class R2&gt; constexpr bool ratio_less_equal_v
    = ratio_less_equal&lt;R1, R2&gt;::value;
  template &lt;class R1, class R2&gt; constexpr bool ratio_greater_v
    = ratio_greater&lt;R1, R2&gt;::value;
  template &lt;class R1, class R2&gt; constexpr bool ratio_greater_equal_v
    = ratio_greater_equal&lt;R1, R2&gt;::value;

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="time">
    

    <section>
      <header><span class="section-number">3.5</span> <h1 data-bookmark-label="3.5 Time utilities">Time utilities</h1> <span style="float:right"><a href="#time">[time]</a></span></header>
      
    

    <cxx-section id="header.chrono.synop">
    

    <section>
      <header><span class="section-number">3.5.1</span> <h1 data-bookmark-label="3.5.1 Header <experimental/chrono> synopsis">Header &lt;experimental/chrono&gt; synopsis</h1> <span style="float:right"><a href="#header.chrono.synop">[header.chrono.synop]</a></span></header>
      
      

<pre><code>#include &lt;chrono&gt;

namespace std {
namespace chrono {
namespace experimental {
inline namespace fundamentals_v1 {

  // See <cxx-ref in="cxx" to="time.traits">C++14 <span title="time.traits">§20.12.4</span></cxx-ref>, customization traits
  template &lt;class Rep&gt; constexpr bool treat_as_floating_point_v
    = treat_as_floating_point&lt;Rep&gt;::value;

} // namespace fundamentals_v1
} // namespace experimental
} // namespace chrono
} // namespace std</code></pre>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="syserror">
    

    <section>
      <header><span class="section-number">3.6</span> <h1 data-bookmark-label="3.6 System error support">System error support</h1> <span style="float:right"><a href="#syserror">[syserror]</a></span></header>
      
    

    <cxx-section id="header.system_error.synop">
    

    <section>
      <header><span class="section-number">3.6.1</span> <h1 data-bookmark-label="3.6.1 Header <experimental/system_error> synopsis">Header &lt;experimental/system_error&gt; synopsis</h1> <span style="float:right"><a href="#header.system_error.synop">[header.system_error.synop]</a></span></header>
      
      

<pre><code>#include &lt;system_error&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  // See <cxx-ref in="cxx" to="syserr">C++14 <span title="syserr">§19.5</span></cxx-ref>, System error support
  template &lt;class T&gt; constexpr bool is_error_code_enum_v
    = is_error_code_enum&lt;T&gt;::value;
  template &lt;class T&gt; constexpr bool is_error_condition_enum_v
    = is_error_condition_enum&lt;T&gt;::value;

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="func">
    

    <section>
      <header><span class="section-number">4</span> <h1 data-bookmark-label="4 Function objects">Function objects</h1> <span style="float:right"><a href="#func">[func]</a></span></header>
      
  

  <cxx-section id="header.functional.synop">
    

    <section>
      <header><span class="section-number">4.1</span> <h1 data-bookmark-label="4.1 Header <experimental/functional> synopsis">Header <code>&lt;experimental/functional&gt;</code> synopsis</h1> <span style="float:right"><a href="#header.functional.synop">[header.functional.synop]</a></span></header>
      
    

    <cxx-ednote class="para">
    
    <aside><strong>Editor's note:</strong> 
    The following header synopsis fixes the missing <tt>noexcept</tt> specifications of the comparison functions as recently resolved by <a href="http://cplusplus.github.io/LWG/lwg-active.html#2401">LWG 2401</a>.
    We consider this change <em>editorial</em> at this point because the two different declarations were already in conflict,
    and this change does not have impact on the actual prototype specifications, which will have the same specifiers as in C++14.
    </aside>
  </cxx-ednote>

<pre><code>#include &lt;functional&gt;

namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    // See <cxx-ref in="cxx" to="bind">C++14 <span title="bind">§20.9.9</span></cxx-ref>, Function object binders
    template &lt;class T&gt; constexpr bool is_bind_expression_v
      = is_bind_expression&lt;T&gt;::value;
    template &lt;class T&gt; constexpr int is_placeholder_v
      = is_placeholder&lt;T&gt;::value;

    <cxx-ref insynopsis="" to="func.wrap.func">// <i><a title="func.wrap.func" href="#func.wrap.func">4.2</a>, Class template function</i></cxx-ref>
    template&lt;class&gt; class function; <i>// undefined</i>
    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) noexcept;
    template&lt;class R, class... ArgTypes&gt;
    bool operator==(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;
    template&lt;class R, class... ArgTypes&gt;
    bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;
    template&lt;class R, class... ArgTypes&gt;
    bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;

    <cxx-ref insynopsis="" to="func.searchers">// <i><a title="func.searchers" href="#func.searchers">4.3</a>, Searchers</i></cxx-ref>
    template&lt;class ForwardIterator, class BinaryPredicate = equal_to&lt;&gt;&gt;
      class default_searcher;

    template&lt;class RandomAccessIterator,
             class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
             class BinaryPredicate = equal_to&lt;&gt;&gt;
      class boyer_moore_searcher;

    template&lt;class RandomAccessIterator,
             class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
             class BinaryPredicate = equal_to&lt;&gt;&gt;
      class boyer_moore_horspool_searcher;


    template&lt;class ForwardIterator, class BinaryPredicate = equal_to&lt;&gt;&gt;
    default_searcher&lt;ForwardIterator, BinaryPredicate&gt;
    make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
                          BinaryPredicate pred = BinaryPredicate());

    template&lt;class RandomAccessIterator,
             class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
             class BinaryPredicate = equal_to&lt;&gt;&gt;
    boyer_moore_searcher&lt;RandomAccessIterator, Hash, BinaryPredicate&gt;
    make_boyer_moore_searcher(
        RandomAccessIterator pat_first, RandomAccessIterator pat_last,
        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

    template&lt;class RandomAccessIterator,
             class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
             class BinaryPredicate = equal_to&lt;&gt;&gt;
    boyer_moore_horspool_searcher&lt;RandomAccessIterator, Hash, BinaryPredicate&gt;
    make_boyer_moore_horspool_searcher(
        RandomAccessIterator pat_first, RandomAccessIterator pat_last,
        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

  } // namespace fundamentals_v1
  } // namespace experimental

  template&lt;class R, class... ArgTypes, class Alloc&gt;
  struct uses_allocator&lt;experimental::function&lt;R(ArgTypes...)&gt;, Alloc&gt;;

} // namespace std</code></pre>

  
    </section>
  </cxx-section>

  <cxx-section id="func.wrap.func">
    

    <section>
      <header><span class="section-number">4.2</span> <h1 data-bookmark-label="4.2 Class template function">Class template <code>function</code></h1> <span style="float:right"><a href="#func.wrap.func">[func.wrap.func]</a></span></header>
      
    

    <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> 
      The following class template synopsis fixes the missing <code>noexcept</code> specification of the <code>nullptr_t</code> assignment operator
      as recently resolved by <a href="http://cplusplus.github.io/LWG/lwg-active.html#2401">LWG 2401</a>.
      We consider this change <em>editorial</em>, because the fundamentals-ts specification otherwise refers to a non-existing declaration in C++14.
    </aside>
  </cxx-ednote>

    <p para_num="1" id="func.wrap.func.1">
      The specification of all declarations within this sub-clause <cxx-ref to="func.wrap.func"><a title="func.wrap.func" href="#func.wrap.func">4.2</a></cxx-ref>
      and its sub-clauses are the same as the corresponding declarations, as specified in <cxx-ref in="cxx" to="func.wrap.func">C++14 <span title="func.wrap.func">§20.9.11.2</span></cxx-ref>,
      unless explicitly specified otherwise. <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    <code>std::experimental::function</code> uses
      <code>std::bad_function_call</code>, there is no additional type <code>std::experimental::bad_function_call</code>
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>.
    </p>

<pre><code>namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    template&lt;class&gt; class function; <i>// undefined</i>

    template&lt;class R, class... ArgTypes&gt;
    class function&lt;R(ArgTypes...)&gt; {
    public:
      typedef R result_type;
      typedef T1 argument_type;
      typedef T1 first_argument_type;
      typedef T2 second_argument_type;

      typedef erased_type allocator_type;

      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) noexcept;
      template&lt;class F&gt; function&amp; operator=(F&amp;&amp;);
      template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt;);

      ~function();

      void swap(function&amp;);
      template&lt;class F, class A&gt; void assign(F&amp;&amp;, const A&amp;);

      explicit operator bool() const noexcept;

      R operator()(ArgTypes...) const;

      const type_info&amp; target_type() const noexcept;
      template&lt;class T&gt; T* target() noexcept;
      template&lt;class T&gt; const T* target() const noexcept;

      pmr::memory_resource* get_memory_resource();
    };

    template &lt;class R, class... ArgTypes&gt;
    bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;
    template &lt;class R, class... ArgTypes&gt;
    bool operator==(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;

    template &lt;class R, class... ArgTypes&gt;
    bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;
    template &lt;class R, class... ArgTypes&gt;
    bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;

    template &lt;class R, class... ArgTypes&gt;
    void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);

  } // namespace fundamentals_v1
  } // namespace experimental

  template &lt;class R, class... ArgTypes, class Alloc&gt;
  struct uses_allocator&lt;experimental::function&lt;R(ArgTypes...)&gt;, Alloc&gt;
    : true_type { };

} // namespace std</code></pre>

    <cxx-section id="func.wrap.func.con">
    

    <section>
      <header><span class="section-number">4.2.1</span> <h1 data-bookmark-label="4.2.1 function construct/copy/destroy"><code>function</code> construct/copy/destroy</h1> <span style="float:right"><a href="#func.wrap.func.con">[func.wrap.func.con]</a></span></header>
      
      

      <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> 
        The following first paragraph has been slightly editorially improved to
        (a) make the difference between <code>std::function</code> and <code>std::experimental::function</code> clearer
        (which seems necessary due to the "including" wording that can be parsed in two different ways) and
        (b) to make intended normative wording clearer, that had been put into parenthesis before, by simply removing these parenthesis.
      </aside>
  </cxx-ednote>

      <p para_num="1" id="func.wrap.func.con.1">
        When a <code>function</code> constructor that takes a first argument of type <code>allocator_arg_t</code> is invoked,
        the second argument is treated as a <cxx-term><i>type-erased allocator</i></cxx-term> (<cxx-ref to="memory.type.erased.allocator"><a title="memory.type.erased.allocator" href="#memory.type.erased.allocator">8.3</a></cxx-ref>).
        If the constructor moves or makes a copy
        of a function object (<cxx-ref in="cxx" to="function.objects">C++14 <span title="function.objects">§20.9</span></cxx-ref>),
        including an instance of the <code>experimental::function</code> class template,
        then that move or copy is performed by <cxx-term><i>using-allocator construction</i></cxx-term> with allocator <code>get_memory_resource()</code>.
      </p>

      <p para_num="2" id="func.wrap.func.con.2">
        In the following descriptions, let <code><em>ALLOCATOR_OF</em>(f)</code> be the allocator specified in the construction of <code>function</code> <code>f</code>,
        or <code>allocator&lt;char&gt;()</code> if no allocator was specified.
      </p>

      <cxx-function para_num="3" id="func.wrap.func.con.3">
    
    <pre><code><cxx-signature>function&amp; operator=(const function&amp; f);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="4" id="func.wrap.func.con.4">
    
    <dt>Effects:</dt><dd><code>function(allocator_arg, <em>ALLOCATOR_OF</em>(*this), f).swap(*this);</code></dd>
  </cxx-effects>
        <cxx-returns para_num="5" id="func.wrap.func.con.5">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="func.wrap.func.con.6">
    
    <pre><code><cxx-signature>function&amp; operator=(function&amp;&amp; f);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="7" id="func.wrap.func.con.7">
    
    <dt>Effects:</dt><dd><code>function(allocator_arg, <em>ALLOCATOR_OF</em>(*this), std::move(f)).swap(*this);</code></dd>
  </cxx-effects>
        <cxx-returns para_num="8" id="func.wrap.func.con.8">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> The following <i>Effects</i> element has been fixed and syncs the wording "<code>*this != NULL</code>"
      with the C++14 working draft replacing it with "<code>*this != nullptr</code>"</aside>
  </cxx-ednote>

      <cxx-function para_num="9" id="func.wrap.func.con.9">
    
    <pre><code><cxx-signature>function&amp; operator=(nullptr_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="10" id="func.wrap.func.con.10">
    
    <dt>Effects:</dt><dd>If <code>*this != nullptr</code>, destroys the target of <code>this</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="11" id="func.wrap.func.con.11">
    
    <dt>Postconditions:</dt><dd><code>!(*this)</code>.
        The memory resource returned by <code>get_memory_resource()</code> after the assignment is equivalent to the memory resource before the assignment.
        <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    the address returned by <code>get_memory_resource()</code> might change
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></dd>
  </cxx-postconditions>
        <cxx-returns para_num="12" id="func.wrap.func.con.12">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="13" id="func.wrap.func.con.13">
    
    <pre><code><cxx-signature>template&lt;class F&gt; function&amp; operator=(F&amp;&amp; f);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="14" id="func.wrap.func.con.14">
    
    <dt>Effects:</dt><dd><code>function(allocator_arg, <em>ALLOCATOR_OF</em>(*this), std::forward&lt;F&gt;(f)).swap(*this);</code></dd>
  </cxx-effects>
        <cxx-returns para_num="15" id="func.wrap.func.con.15">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="16" id="func.wrap.func.con.16">
    
    <pre><code><cxx-signature>template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt; f);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="17" id="func.wrap.func.con.17">
    
    <dt>Effects:</dt><dd><code>function(allocator_arg, <em>ALLOCATOR_OF</em>(*this), f).swap(*this);</code></dd>
  </cxx-effects>
        <cxx-returns para_num="18" id="func.wrap.func.con.18">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="func.wrap.func.mod">
    

    <section>
      <header><span class="section-number">4.2.2</span> <h1 data-bookmark-label="4.2.2 function modifiers"><code>function</code> modifiers</h1> <span style="float:right"><a href="#func.wrap.func.mod">[func.wrap.func.mod]</a></span></header>
      
      

      <cxx-function para_num="1" id="func.wrap.func.mod.1">
    
    <pre><code><cxx-signature>void swap(function&amp; other);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="func.wrap.func.mod.2">
    
    <dt>Requires:</dt><dd><code>this-&gt;get_memory_resource() == other-&gt;get_memory_resource()</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="3" id="func.wrap.func.mod.3">
    
    <dt>Effects:</dt><dd>Interchanges the targets of <code>*this</code> and <code>other</code>.</dd>
  </cxx-effects>
        <cxx-remarks para_num="4" id="func.wrap.func.mod.4">
    
    <dt>Remarks:</dt><dd>The allocators of <code>*this</code> and <code>other</code> are not interchanged.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="func.searchers">
    

    <section>
      <header><span class="section-number">4.3</span> <h1 data-bookmark-label="4.3 Searchers">Searchers</h1> <span style="float:right"><a href="#func.searchers">[func.searchers]</a></span></header>
      
    

    <p para_num="1" id="func.searchers.1">
      This sub-clause provides function object types (<cxx-ref in="cxx" to="function.objects">C++14 <span title="function.objects">§20.9</span></cxx-ref>) for operations
      that search for a sequence <cxx-range begin="pat_first" end="pat_last">[<code>pat_first</code>, <code>pat_last</code>)</cxx-range> in another sequence <cxx-range begin="first" end="last">[<code>first</code>, <code>last</code>)</cxx-range>
      that is provided to the object's function call operator.
      The first sequence (the pattern to be searched for) is provided to the object's constructor,
      and the second (the sequence to be searched) is provided to the function call operator.
    </p>

    <p para_num="2" id="func.searchers.2">
      Each specialization of a class template specified in this sub-clause <cxx-ref to="func.searchers"><a title="func.searchers" href="#func.searchers">4.3</a></cxx-ref> shall meet the <code>CopyConstructible</code> and <code>CopyAssignable</code> requirements.
      Template parameters named <code>ForwardIterator</code>, <code>ForwardIterator1</code>, <code>ForwardIterator2</code>, <code>RandomAccessIterator</code>, <code>RandomAccessIterator1</code>, <code>RandomAccessIterator2</code>, and <code>BinaryPredicate</code> of templates specified in this sub-clause <cxx-ref to="func.searchers"><a title="func.searchers" href="#func.searchers">4.3</a></cxx-ref> shall meet the same requirements and semantics as specified in <cxx-ref in="cxx" to="algorithms.general">C++14 <span title="algorithms.general">§25.1</span></cxx-ref>.
      Template parameters named <code>Hash</code> shall meet the requirements as specified in <cxx-ref in="cxx" to="hash.requirements">C++14 <span title="hash.requirements">§17.6.3.4</span></cxx-ref>.
    </p>

    <p para_num="3" id="func.searchers.3">
      The Boyer-Moore searcher implements the Boyer-Moore search algorithm.
      The Boyer-Moore-Horspool searcher implements the Boyer-Moore-Horspool search algorithm.
      In general, the Boyer-Moore searcher will use more memory and give better run-time performance than Boyer-Moore-Horspool
    </p>

    <cxx-section id="func.searchers.default">
    

    <section>
      <header><span class="section-number">4.3.1</span> <h1 data-bookmark-label="4.3.1 Class template default_searcher">Class template <code>default_searcher</code></h1> <span style="float:right"><a href="#func.searchers.default">[func.searchers.default]</a></span></header>
      
      

      <pre><code>template&lt;class ForwardIterator1, class BinaryPredicate = equal_to&lt;&gt;&gt;
class default_searcher {
public:
  default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                   BinaryPredicate pred = BinaryPredicate());

  template&lt;class ForwardIterator2&gt;
  ForwardIterator2
  operator()(ForwardIterator2 first, ForwardIterator2 last) const;

private:
  ForwardIterator1 pat_first_; <i>// exposition only</i>
  ForwardIterator1 pat_last_;  <i>// exposition only</i>
  BinaryPredicate  pred_;      <i>// exposition only</i>
};
</code></pre>

      <cxx-function para_num="1" id="func.searchers.default.1">
    
    <pre><code><cxx-signature>default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
BinaryPredicate pred = BinaryPredicate());</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="func.searchers.default.2">
    
    <dt>Effects:</dt><dd>Constructs a <code>default_searcher</code> object, initializing <code>pat_first_</code> with <code>pat_first</code>, <code>pat_last_</code> with <code>pat_last</code>, and <code>pred_</code> with <code>pred</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="3" id="func.searchers.default.3">
    
    <dt>Throws:</dt><dd>Any exception thrown by the copy constructor of <code>BinaryPredicate</code> or <code>ForwardIterator1</code>.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="4" id="func.searchers.default.4">
    
    <pre><code><cxx-signature>template&lt;class ForwardIterator2&gt;
ForwardIterator2 operator()(ForwardIterator2 first, ForwardIterator2 last) const;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="5" id="func.searchers.default.5">
    
    <dt>Effects:</dt><dd>Equivalent to <code>std::search(first, last, pat_first_, pat_last_, pred_)</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-section id="func.searchers.default.creation">
    

    <section>
      <header><span class="section-number">4.3.1.1</span> <h1 data-bookmark-label="4.3.1.1 default_searcher creation functions"><code>default_searcher</code> creation functions</h1> <span style="float:right"><a href="#func.searchers.default.creation">[func.searchers.default.creation]</a></span></header>
      
        

        <cxx-function para_num="1" id="func.searchers.default.creation.1">
    
    <pre><code><cxx-signature>template&lt;class ForwardIterator, class BinaryPredicate = equal_to&lt;&gt;&gt;
default_searcher&lt;ForwardIterator, BinaryPredicate&gt;
make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
                      BinaryPredicate pred = BinaryPredicate());</cxx-signature></code></pre>

    <dl>
      
          

          <cxx-effects para_num="2" id="func.searchers.default.creation.2">
    
    <dt>Effects:</dt><dd>Equivalent to <code>default_searcher&lt;ForwardIterator, BinaryPredicate&gt;(pat_first, pat_last, pred)</code>.</dd>
  </cxx-effects>
        
    </dl>
  </cxx-function>
      
    </section>
  </cxx-section>
    
    </section>
  </cxx-section>

    <cxx-section id="func.searchers.boyer_moore">
    

    <section>
      <header><span class="section-number">4.3.2</span> <h1 data-bookmark-label="4.3.2 Class template boyer_moore_searcher">Class template <code>boyer_moore_searcher</code></h1> <span style="float:right"><a href="#func.searchers.boyer_moore">[func.searchers.boyer_moore]</a></span></header>
      
      

<pre><code>template&lt;class RandomAccessIterator1,
         class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator1&gt;::value_type&gt;,
         class BinaryPredicate = equal_to&lt;&gt;&gt;
class boyer_moore_searcher {
public:
  boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
                       Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

  template&lt;class RandomAccessIterator2&gt;
  RandomAccessIterator2
  operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

private:
  RandomAccessIterator1 pat_first_; <i>// exposition only</i>
  RandomAccessIterator1 pat_last_;  <i>// exposition only</i>
  Hash                  hash_;      <i>// exposition only</i>
  BinaryPredicate       pred_;      <i>// exposition only</i>
};
</code></pre>

      <cxx-function para_num="1" id="func.searchers.boyer_moore.1">
    
    <pre><code><cxx-signature>boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
Hash hf = Hash(),
BinaryPredicate pred = BinaryPredicate());</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="func.searchers.boyer_moore.2">
    
    <dt>Requires:</dt><dd>The value type of <code>RandomAccessIterator1</code> shall meet the <code>DefaultConstructible</code>, <code>CopyConstructible</code>, and <code>CopyAssignable</code> requirements.</dd>
  </cxx-requires>
        <cxx-requires para_num="3" id="func.searchers.boyer_moore.3">
    
    <dt>Requires:</dt><dd>For any two values <code>A</code> and <code>B</code> of the type <code>iterator_traits&lt;RandomAccessIterator1&gt;::value_type</code>, if <code>pred(A,B)==true</code>, then <code>hf(A)==hf(B)</code> shall be true.</dd>
  </cxx-requires>
        <cxx-effects para_num="4" id="func.searchers.boyer_moore.4">
    
    <dt>Effects:</dt><dd>Constructs a <code>boyer_moore_searcher</code> object, initializing <code>pat_first_</code> with <code>pat_first</code>, <code>pat_last_</code> with <code>pat_last</code>, <code>hash_</code> with <code>hf</code>, and <code>pred_</code> with <code>pred</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="5" id="func.searchers.boyer_moore.5">
    
    <dt>Throws:</dt><dd>Any exception thrown by the copy constructor of <code>RandomAccessIterator1</code>,
        or by the default constructor, copy constructor, or the copy assignment operator of the value type of <code>RandomAccessIterator1</code>,
        or the copy constructor or <code>operator()</code> of <code>BinaryPredicate</code> or <code>Hash</code>.
        May throw <code>bad_alloc</code> if additional memory needed for internal data structures cannot be allocated.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="func.searchers.boyer_moore.6">
    
    <pre><code><cxx-signature>template&lt;class RandomAccessIterator2&gt;
RandomAccessIterator2 operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="7" id="func.searchers.boyer_moore.7">
    
    <dt>Requires:</dt><dd><code>RandomAccessIterator1</code> and <code>RandomAccessIterator2</code> shall have the same value type.</dd>
  </cxx-requires>
        <cxx-effects para_num="8" id="func.searchers.boyer_moore.8">
    
    <dt>Effects:</dt><dd>Finds a subsequence of equal values in a sequence.</dd>
  </cxx-effects>
        <cxx-returns para_num="9" id="func.searchers.boyer_moore.9">
    
    <dt>Returns:</dt><dd>
          The first iterator <code>i</code> in the range <cxx-range begin="first" end="last - (pat_last_ - pat_first_)">[<code>first</code>, <code>last - (pat_last_ - pat_first_)</code>)</cxx-range>
          such that for every non-negative integer <code>n</code> less than <code>pat_last_ - pat_first_</code> the following condition holds:
          <code>pred(*(i + n), *(pat_first_ + n)) != false</code>.
          Returns <code>first</code> if <cxx-range begin="pat_first_" end="pat_last_">[<code>pat_first_</code>, <code>pat_last_</code>)</cxx-range> is empty,
          otherwise returns <code>last</code> if no such iterator is found.
        </dd>
  </cxx-returns>
        <cxx-complexity para_num="10" id="func.searchers.boyer_moore.10">
    
    <dt>Complexity:</dt><dd>At most <code>(last - first) * (pat_last_ - pat_first_)</code> applications of the predicate.</dd>
  </cxx-complexity>
      
    </dl>
  </cxx-function>

      <cxx-section id="func.searchers.boyer_moore.creation">
    

    <section>
      <header><span class="section-number">4.3.2.1</span> <h1 data-bookmark-label="4.3.2.1 boyer_moore_searcher creation functions"><code>boyer_moore_searcher</code> creation functions</h1> <span style="float:right"><a href="#func.searchers.boyer_moore.creation">[func.searchers.boyer_moore.creation]</a></span></header>
      
        

        <cxx-function para_num="1" id="func.searchers.boyer_moore.creation.1">
    
    <pre><code><cxx-signature>template&lt;class RandomAccessIterator,
class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
class BinaryPredicate = equal_to&lt;&gt;&gt;
  boyer_moore_searcher&lt;RandomAccessIterator, Hash, BinaryPredicate&gt;
  make_boyer_moore_searcher(RandomAccessIterator pat_first, RandomAccessIterator pat_last,
                            Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());</cxx-signature></code></pre>

    <dl>
      
          

          <cxx-effects para_num="2" id="func.searchers.boyer_moore.creation.2">
    
    <dt>Effects:</dt><dd>Equivalent to <code>boyer_moore_searcher&lt;RandomAccessIterator, Hash, BinaryPredicate&gt;(<w-br><wbr></w-br>pat_first, pat_last, hf, pred)</code>.</dd>
  </cxx-effects>
        
    </dl>
  </cxx-function>
      
    </section>
  </cxx-section>
    
    </section>
  </cxx-section>

    <cxx-section id="func.searchers.boyer_moore_horspool">
    

    <section>
      <header><span class="section-number">4.3.3</span> <h1 data-bookmark-label="4.3.3 Class template boyer_moore_horspool_searcher">Class template <code>boyer_moore_horspool_searcher</code></h1> <span style="float:right"><a href="#func.searchers.boyer_moore_horspool">[func.searchers.boyer_moore_horspool]</a></span></header>
      
      

<pre><code>
template&lt;class RandomAccessIterator1,
         class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator1&gt;::value_type&gt;,
         class BinaryPredicate = equal_to&lt;&gt;&gt;
class boyer_moore_horspool_searcher {
public:
  boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
                                Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

  template&lt;class RandomAccessIterator2&gt;
  RandomAccessIterator2
  operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

private:
  RandomAccessIterator1 pat_first_; <i>// exposition only</i>
  RandomAccessIterator1 pat_last_;  <i>// exposition only</i>
  Hash                  hash_;      <i>// exposition only</i>
  BinaryPredicate       pred_;      <i>// exposition only</i>
};
</code></pre>

      <cxx-function para_num="1" id="func.searchers.boyer_moore_horspool.1">
    
    <pre><code><cxx-signature>boyer_moore_horspool_searcher(
RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="func.searchers.boyer_moore_horspool.2">
    
    <dt>Requires:</dt><dd>The value type of <code>RandomAccessIterator1</code> shall meet the <code>DefaultConstructible</code>, <code>CopyConstructible</code>, and <code>CopyAssignable</code> requirements.</dd>
  </cxx-requires>
        <cxx-requires para_num="3" id="func.searchers.boyer_moore_horspool.3">
    
    <dt>Requires:</dt><dd>For any two values <code>A</code> and <code>B</code> of the type <code>iterator_traits&lt;RandomAccessIterator1&gt;::value_type</code>,
        if <code>pred(A,B)==true</code>, then <code>hf(A)==hf(B)</code> shall be true.</dd>
  </cxx-requires>
        <cxx-effects para_num="4" id="func.searchers.boyer_moore_horspool.4">
    
    <dt>Effects:</dt><dd>Constructs a <code>boyer_moore_horspool_searcher</code> object, initializing <code>pat_first_</code> with <code>pat_first</code>,
        <code>pat_last_</code> with <code>pat_last</code>, <code>hash_</code> with <code>hf</code>, and <code>pred_</code> with <code>pred</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="5" id="func.searchers.boyer_moore_horspool.5">
    
    <dt>Throws:</dt><dd>
          Any exception thrown by the copy constructor of <code>RandomAccessIterator1</code>,
          or by the default constructor, copy constructor, or the copy assignment operator of the value type of <code>RandomAccessIterator1</code>
          or the copy constructor or <code>operator()</code> of <code>BinaryPredicate</code> or <code>Hash</code>.
          May throw <code>bad_alloc</code> if additional memory needed for internal data structures cannot be allocated..
        </dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="func.searchers.boyer_moore_horspool.6">
    
    <pre><code><cxx-signature>template&lt;class RandomAccessIterator2&gt;
RandomAccessIterator2 operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="7" id="func.searchers.boyer_moore_horspool.7">
    
    <dt>Requires:</dt><dd><code>RandomAccessIterator1</code> and <code>RandomAccessIterator2</code> shall have the same value type.</dd>
  </cxx-requires>
        <cxx-effects para_num="8" id="func.searchers.boyer_moore_horspool.8">
    
    <dt>Effects:</dt><dd>Finds a subsequence of equal values in a sequence.</dd>
  </cxx-effects>
        <cxx-returns para_num="9" id="func.searchers.boyer_moore_horspool.9">
    
    <dt>Returns:</dt><dd>
          The first iterator <code>i</code> in the range <cxx-range begin="first" end="last - (pat_last_ - pat_first_)">[<code>first</code>, <code>last - (pat_last_ - pat_first_)</code>)</cxx-range>
          such that for every non-negative integer <code>n</code> less than <code>pat_last_ - pat_first_</code> the following condition holds:
          <code>pred(*(i + n), *(pat_first_ + n)) != false</code>.
          Returns <code>first</code> if <cxx-range begin="pat_first_" end="pat_last_">[<code>pat_first_</code>, <code>pat_last_</code>)</cxx-range> is empty,
          otherwise returns <code>last</code> if no such iterator is found.
        </dd>
  </cxx-returns>
        <cxx-complexity para_num="10" id="func.searchers.boyer_moore_horspool.10">
    
    <dt>Complexity:</dt><dd>At most <code>(last - first) * (pat_last_ - pat_first_)</code> applications of the predicate.</dd>
  </cxx-complexity>
      
    </dl>
  </cxx-function>

      <cxx-section id="func.searchers.boyer_moore_horspool.creation">
    

    <section>
      <header><span class="section-number">4.3.3.1</span> <h1 data-bookmark-label="4.3.3.1 boyer_moore_horspool_searcher creation functions"><code>boyer_moore_horspool_searcher</code> creation functions</h1> <span style="float:right"><a href="#func.searchers.boyer_moore_horspool.creation">[func.searchers.boyer_moore_horspool.creation]</a></span></header>
      
        

        <cxx-function para_num="1" id="func.searchers.boyer_moore_horspool.creation.1">
    
    <pre><code><cxx-signature>template&lt;class RandomAccessIterator,
         class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
         class BinaryPredicate = equal_to&lt;&gt;&gt;
boyer_moore_searcher_horspool&lt;RandomAccessIterator, Hash, BinaryPredicate&gt;
make_boyer_moore_horspool_searcher(
    RandomAccessIterator pat_first, RandomAccessIterator pat_last,
    Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());</cxx-signature></code></pre>

    <dl>
      
          

          <cxx-effects para_num="2" id="func.searchers.boyer_moore_horspool.creation.2">
    
    <dt>Effects:</dt><dd>Equivalent to <code>boyer_moore_horspool_searcher&lt;RandomAccessIterator, Hash, BinaryPredicate&gt;(<w-br><wbr></w-br>pat_first, pat_last, hf, pred)</code>.</dd>
  </cxx-effects>
        
    </dl>
  </cxx-function>
      
    </section>
  </cxx-section>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="optional">
    

    <section>
      <header><span class="section-number">5</span> <h1 data-bookmark-label="5 Optional objects">Optional objects</h1> <span style="float:right"><a href="#optional">[optional]</a></span></header>
      
  

  <cxx-section id="optional.general">
    

    <section>
      <header><span class="section-number">5.1</span> <h1 data-bookmark-label="5.1 In general">In general</h1> <span style="float:right"><a href="#optional.general">[optional.general]</a></span></header>
      
    

    <p para_num="1" id="optional.general.1">This subclause describes class template <code>optional</code> that represents <em>optional objects</em>. An <dfn>optional object for object types</dfn> is an object that contains the storage for another object and manages the lifetime of this contained object, if any. The contained object may be initialized after the optional object has been initialized, and may be destroyed before the optional object has been destroyed. The initialization state of the contained object is tracked by the optional object.</p>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.synop">
    

    <section>
      <header><span class="section-number">5.2</span> <h1 data-bookmark-label="5.2 Header <experimental/optional> synopsis">Header <code>&lt;experimental/optional&gt;</code> synopsis</h1> <span style="float:right"><a href="#optional.synop">[optional.synop]</a></span></header>
      
    

<pre><code>namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    <cxx-ref insynopsis="" to="optional.object">// <i><a title="optional.object" href="#optional.object">5.3</a>, optional for object types</i></cxx-ref>
    template &lt;class T&gt; class optional;

    <cxx-ref insynopsis="" to="optional.inplace">// <i><a title="optional.inplace" href="#optional.inplace">5.4</a>, In-place construction</i></cxx-ref>
    struct in_place_t{};
    constexpr in_place_t in_place{};

    <cxx-ref insynopsis="" to="optional.nullopt">// <i><a title="optional.nullopt" href="#optional.nullopt">5.5</a>, No-value state indicator</i></cxx-ref>
    struct nullopt_t{<em>see below</em>};
    constexpr nullopt_t nullopt(<em>unspecified</em>);

    <cxx-ref insynopsis="" to="optional.bad_optional_access">// <i><a title="optional.bad_optional_access" href="#optional.bad_optional_access">5.6</a>, Class bad_optional_access</i></cxx-ref>
    class bad_optional_access;

    <cxx-ref insynopsis="" to="optional.relops">// <i><a title="optional.relops" href="#optional.relops">5.7</a>, Relational operators</i></cxx-ref>
    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;);

    <cxx-ref insynopsis="" to="optional.nullops">// <i><a title="optional.nullops" href="#optional.nullops">5.8</a>, Comparison with nullopt</i></cxx-ref>
    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;

    <cxx-ref insynopsis="" to="optional.comp_with_t">// <i><a title="optional.comp_with_t" href="#optional.comp_with_t">5.9</a>, Comparison with T</i></cxx-ref>
    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;);

    <cxx-ref insynopsis="" to="optional.specalg">// <i><a title="optional.specalg" href="#optional.specalg">5.10</a>, Specialized algorithms</i></cxx-ref>
    template &lt;class T&gt; void swap(optional&lt;T&gt;&amp;, optional&lt;T&gt;&amp;) noexcept(<em>see below</em>);
    template &lt;class T&gt; constexpr optional&lt;<em>see below</em>&gt; make_optional(T&amp;&amp;);

  } // <i>namespace fundamentals_v1</i>
  } // <i>namespace experimental</i>

  <cxx-ref insynopsis="" to="optional.hash">// <i><a title="optional.hash" href="#optional.hash">5.11</a>, Hash support</i></cxx-ref>
  template &lt;class T&gt; struct hash;
  template &lt;class T&gt; struct hash&lt;experimental::optional&lt;T&gt;&gt;;

} // <i>namespace std</i></code></pre>

    <p para_num="1" id="optional.synop.1">A program that necessitates the instantiation of template <code>optional</code> for a reference type, or for possibly cv-qualified types <code>in_place_t</code> or <code>nullopt_t</code> is ill-formed.</p>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.object">
    

    <section>
      <header><span class="section-number">5.3</span> <h1 data-bookmark-label="5.3 optional for object types"><code>optional</code> for object types</h1> <span style="float:right"><a href="#optional.object">[optional.object]</a></span></header>
      
    

<pre><code>template &lt;class T&gt;
class optional
{
public:
  typedef T value_type;

  <cxx-ref insynopsis="" to="optional.object.ctor">// <i><a title="optional.object.ctor" href="#optional.object.ctor">5.3.1</a>, Constructors</i></cxx-ref>
  constexpr optional() noexcept;
  constexpr optional(nullopt_t) noexcept;
  optional(const optional&amp;);
  optional(optional&amp;&amp;) noexcept(<em>see below</em>);
  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;...);

  <cxx-ref insynopsis="" to="optional.object.dtor">// <i><a title="optional.object.dtor" href="#optional.object.dtor">5.3.2</a>, Destructor</i></cxx-ref>
  ~optional();

  <cxx-ref insynopsis="" to="optional.object.assign">// <i><a title="optional.object.assign" href="#optional.object.assign">5.3.3</a>, Assignment</i></cxx-ref>
  optional&amp; operator=(nullopt_t) noexcept;
  optional&amp; operator=(const optional&amp;);
  optional&amp; operator=(optional&amp;&amp;) noexcept(<em>see below</em>);
  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;...);

  <cxx-ref insynopsis="" to="optional.object.swap">// <i><a title="optional.object.swap" href="#optional.object.swap">5.3.4</a>, Swap</i></cxx-ref>
  void swap(optional&amp;) noexcept(<em>see below</em>);

  <cxx-ref insynopsis="" to="optional.object.observe">// <i><a title="optional.object.observe" href="#optional.object.observe">5.3.5</a>, Observers</i></cxx-ref>
  constexpr T const* operator -&gt;() const;
  constexpr T* operator -&gt;();
  constexpr T const&amp; operator *() const &amp;;
  constexpr T&amp; operator *() &amp;;
  constexpr T&amp;&amp; operator *() &amp;&amp;;
  constexpr const T&amp;&amp; operator *() const &amp;&amp;;
  constexpr explicit operator bool() const noexcept;
  constexpr T const&amp; value() const &amp;;
  constexpr T&amp; value() &amp;;
  constexpr T&amp;&amp; value() &amp;&amp;;
  constexpr const T&amp;&amp; value() const &amp;&amp;;
  template &lt;class U&gt; constexpr T value_or(U&amp;&amp;) const &amp;;
  template &lt;class U&gt; constexpr T value_or(U&amp;&amp;) &amp;&amp;;

private:
  T*   val;  // <i>exposition only</i>
};</code></pre>

    <p para_num="1" id="optional.object.1">
      Any instance of <code>optional&lt;T&gt;</code> at any given time either contains a value or does not contain a value.
      When an instance of <code>optional&lt;T&gt;</code> <dfn>contains a value</dfn>,
      it means that an object of type <code>T</code>, referred to as the optional object's <dfn>contained value</dfn>,
      is allocated within the storage of the optional object.
      Implementations are not permitted to use additional storage, such as dynamic memory, to allocate its contained value.
      The contained value shall be allocated in a region of the <code>optional&lt;T&gt;</code> storage suitably aligned for the type <code>T</code>.
      When an object of type <code>optional&lt;T&gt;</code> is contextually converted to <code>bool</code>,
      the conversion returns <code>true</code> if the object contains a value;
      otherwise the conversion returns <code>false</code>.
    </p>

    <p para_num="2" id="optional.object.2">Member <code>val</code> is provided for exposition only. When an <code>optional&lt;T&gt;</code> object contains a value, <code>val</code> points to the contained value.</p>

    <p para_num="3" id="optional.object.3"><code>T</code> shall be an object type and shall satisfy the requirements of <code>Destructible</code> (Table 24).</p>

    <cxx-section id="optional.object.ctor">
    

    <section>
      <header><span class="section-number">5.3.1</span> <h1 data-bookmark-label="5.3.1 Constructors">Constructors</h1> <span style="float:right"><a href="#optional.object.ctor">[optional.object.ctor]</a></span></header>
      
      

      <cxx-function para_num="1" id="optional.object.ctor.1">
    
    <pre><code><cxx-signature>constexpr optional() noexcept;</cxx-signature><cxx-signature>constexpr optional(nullopt_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-postconditions para_num="2" id="optional.object.ctor.2">
    
    <dt>Postconditions:</dt><dd><code>*this</code> does not contain a value.</dd>
  </cxx-postconditions>
        <cxx-remarks para_num="3" id="optional.object.ctor.3">
    
    <dt>Remarks:</dt><dd>No contained value is initialized.
        For every object type <code>T</code> these constructors shall be <code>constexpr</code> constructors (<cxx-ref in="cxx" to="dcl.constexpr">C++14 <span title="dcl.constexpr">§7.1.5</span></cxx-ref>).</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="4" id="optional.object.ctor.4">
    
    <pre><code><cxx-signature>optional(const optional&lt;T&gt;&amp; <var>rhs</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="5" id="optional.object.ctor.5">
    
    <dt>Requires:</dt><dd><code>is_copy_constructible_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="6" id="optional.object.ctor.6">
    
    <dt>Effects:</dt><dd>If <code><var>rhs</var></code> contains a value, initializes the contained value as if
        direct-non-list-initializing an object of type <code>T</code> with the expression <code>*<var>rhs</var></code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="7" id="optional.object.ctor.7">
    
    <dt>Postconditions:</dt><dd><code>bool(<var>rhs</var>) == bool(*this)</code>.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="8" id="optional.object.ctor.8">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="9" id="optional.object.ctor.9">
    
    <pre><code><cxx-signature>optional(optional&lt;T&gt;&amp;&amp; <var>rhs</var>) noexcept(<em>see below</em>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="10" id="optional.object.ctor.10">
    
    <dt>Requires:</dt><dd><code>is_move_constructible_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="11" id="optional.object.ctor.11">
    
    <dt>Effects:</dt><dd>If <code><var>rhs</var></code> contains a value, initializes the contained value as if
        direct-non-list-initializing an object of type <code>T</code> with the expression <code>std::move(*<var>rhs</var>)</code>.
        <code>bool(<var>rhs</var>)</code> is unchanged.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="12" id="optional.object.ctor.12">
    
    <dt>Postconditions:</dt><dd><code>bool(<var>rhs</var>) == bool(*this)</code>.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="13" id="optional.object.ctor.13">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="14" id="optional.object.ctor.14">
    
    <dt>Remarks:</dt><dd>The expression inside <code>noexcept</code> is equivalent to:<pre><code>is_nothrow_move_constructible_v&lt;T&gt;</code></pre></dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="15" id="optional.object.ctor.15">
    
    <pre><code><cxx-signature>constexpr optional(const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="16" id="optional.object.ctor.16">
    
    <dt>Requires:</dt><dd><code>is_copy_constructible_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="17" id="optional.object.ctor.17">
    
    <dt>Effects:</dt><dd>Initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with the expression <code><var>v</var></code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="18" id="optional.object.ctor.18">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="19" id="optional.object.ctor.19">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="20" id="optional.object.ctor.20">
    
    <dt>Remarks:</dt><dd>If <code>T</code>'s selected constructor is a <code>constexpr</code> constructor, this constructor shall be a <code>constexpr</code> constructor.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="21" id="optional.object.ctor.21">
    
    <pre><code><cxx-signature>constexpr optional(T&amp;&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="22" id="optional.object.ctor.22">
    
    <dt>Requires:</dt><dd><code>is_move_constructible_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="23" id="optional.object.ctor.23">
    
    <dt>Effects:</dt><dd>Initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with the expression <code>std::move(<var>v</var>)</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="24" id="optional.object.ctor.24">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="25" id="optional.object.ctor.25">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="26" id="optional.object.ctor.26">
    
    <dt>Remarks:</dt><dd>If <code>T</code>'s selected constructor is a <code>constexpr</code> constructor, this constructor shall be a <code>constexpr</code> constructor.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="27" id="optional.object.ctor.27">
    
    <pre><code><cxx-signature>template &lt;class... Args&gt; constexpr explicit optional(in_place_t, Args&amp;&amp;... <var>args</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="28" id="optional.object.ctor.28">
    
    <dt>Requires:</dt><dd><code>is_constructible_v&lt;T, Args&amp;&amp;...&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="29" id="optional.object.ctor.29">
    
    <dt>Effects:</dt><dd>Initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with the arguments <code>std::forward&lt;Args&gt;(<var>args</var>)...</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="30" id="optional.object.ctor.30">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="31" id="optional.object.ctor.31">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="32" id="optional.object.ctor.32">
    
    <dt>Remarks:</dt><dd>If <code>T</code>'s constructor selected for the initialization is a <code>constexpr</code> constructor, this constructor shall be a <code>constexpr</code> constructor.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="33" id="optional.object.ctor.33">
    
    <pre><code><cxx-signature>template &lt;class U, class... Args&gt;
constexpr explicit optional(in_place_t, initializer_list&lt;U&gt; <var>il</var>, Args&amp;&amp;... <var>args</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="34" id="optional.object.ctor.34">
    
    <dt>Requires:</dt><dd><code>is_constructible_v&lt;T, initializer_list&lt;U&gt;&amp;, Args&amp;&amp;...&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="35" id="optional.object.ctor.35">
    
    <dt>Effects:</dt><dd>Initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with the arguments <code><var>il</var>, std::forward&lt;Args&gt;(<var>args</var>)...</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="36" id="optional.object.ctor.36">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="37" id="optional.object.ctor.37">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="38" id="optional.object.ctor.38">
    
    <dt>Remarks:</dt><dd>The function shall not participate in overload resolution unless <code>is_constructible_v&lt;T, initializer_list&lt;U&gt;&amp;, Args&amp;&amp;...&gt;</code> is <code>true</code>.
        If <code>T</code>'s constructor selected for the initialization is a <code>constexpr</code> constructor, this constructor shall be a <code>constexpr</code> constructor.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="optional.object.dtor">
    

    <section>
      <header><span class="section-number">5.3.2</span> <h1 data-bookmark-label="5.3.2 Destructor">Destructor</h1> <span style="float:right"><a href="#optional.object.dtor">[optional.object.dtor]</a></span></header>
      
      

      <cxx-function para_num="1" id="optional.object.dtor.1">
    
    <pre><code><cxx-signature>~optional();</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="optional.object.dtor.2">
    
    <dt>Effects:</dt><dd>If <code>is_trivially_destructible_v&lt;T&gt; != true</code> and <code>*this</code> contains a value, calls <code><var>val</var>-&gt;T::~T()</code>.</dd>
  </cxx-effects>
        <cxx-remarks para_num="3" id="optional.object.dtor.3">
    
    <dt>Remarks:</dt><dd>If <code>is_trivially_destructible_v&lt;T&gt; == true</code> then this destructor shall be a trivial destructor.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="optional.object.assign">
    

    <section>
      <header><span class="section-number">5.3.3</span> <h1 data-bookmark-label="5.3.3 Assignment">Assignment</h1> <span style="float:right"><a href="#optional.object.assign">[optional.object.assign]</a></span></header>
      
      

      <cxx-function para_num="1" id="optional.object.assign.1">
    
    <pre><code><cxx-signature>optional&lt;T&gt;&amp; operator=(nullopt_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="optional.object.assign.2">
    
    <dt>Effects:</dt><dd>If <code>*this</code> contains a value, calls <code><var>val</var>-&gt;T::~T()</code> to destroy the contained value; otherwise no effect.</dd>
  </cxx-effects>
        <cxx-returns para_num="3" id="optional.object.assign.3">
    
    <dt>Returns:</dt><dd><code>*this</code>.</dd>
  </cxx-returns>
        <cxx-postconditions para_num="4" id="optional.object.assign.4">
    
    <dt>Postconditions:</dt><dd><code>*this</code> does not contain a value.</dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="optional.object.assign.5">
    
    <pre><code><cxx-signature>optional&lt;T&gt;&amp; operator=(const optional&lt;T&gt;&amp; <var>rhs</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="6" id="optional.object.assign.6">
    
    <dt>Requires:</dt><dd><code>is_copy_constructible_v&lt;T&gt;</code> is <code>true</code> and <code>is_copy_assignable_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="7" id="optional.object.assign.7">
    
    <dt>Effects:</dt><dd>
          <table is="cxx-table" class="single-border column-rules">
    

    <caption>Table 4 — <wbr><span><code>optional::operator=(const optional&amp;)</code> effects</span></caption>
    
            
            <tbody><tr>
              <th></th>
              <th><code>*this</code> contains a value</th>
              <th><code>*this</code> does not contain a value</th>
            </tr>
            <tr>
              <th><code>rhs</code> contains a value</th>
              <td>assigns <code>*rhs</code> to the contained value</td>
              <td>initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with <code>*rhs</code></td>
            </tr>
            <tr>
              <th><code>rhs</code> does not contain a value</th>
              <td>destroys the contained value by calling <code>val-&gt;T::~T()</code></td>
              <td>no effect</td>
            </tr>
          </tbody>
  </table>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="8" id="optional.object.assign.8">
    
    <dt>Returns:</dt><dd><code>*this</code>.</dd>
  </cxx-returns>
        <cxx-postconditions para_num="9" id="optional.object.assign.9">
    
    <dt>Postconditions:</dt><dd><code>bool(<var>rhs</var>) == bool(*this)</code>.</dd>
  </cxx-postconditions>
        <cxx-remarks para_num="10" id="optional.object.assign.10">
    
    <dt>Remarks:</dt><dd>
          If any exception is thrown, the result of the expression <code>bool(*this)</code> remains unchanged.
          If an exception is thrown during the call to <code>T</code>'s copy constructor, no effect.
          If an exception is thrown during the call to <code>T</code>'s copy assignment,
          the state of its contained value is as defined by the exception safety guarantee of <code>T</code>'s copy assignment.
        </dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="11" id="optional.object.assign.11">
    
    <pre><code><cxx-signature>optional&lt;T&gt;&amp; operator=(optional&lt;T&gt;&amp;&amp; <var>rhs</var>) noexcept(<em>see below</em>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="12" id="optional.object.assign.12">
    
    <dt>Requires:</dt><dd><code>is_move_constructible_v&lt;T&gt;</code> is <code>true</code> and <code>is_move_assignable_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="13" id="optional.object.assign.13">
    
    <dt>Effects:</dt><dd>The result of the expression <code>bool(rhs)</code> remains unchanged.

          <table is="cxx-table" class="single-border column-rules">
    

    <caption>Table 5 — <wbr><span><code>optional::operator=(optional&amp;&amp;)</code> effects</span></caption>
    
            
            <tbody><tr>
              <th></th>
              <th><code>*this</code> contains a value</th>
              <th><code>*this</code> does not contain a value</th>
            </tr>
            <tr>
              <th><code>rhs</code> contains a value</th>
              <td>assigns <code>std::move(*rhs)</code> to the contained value</td>
              <td>initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with <code>std::move(*rhs)</code></td>
            </tr>
            <tr>
              <th><code>rhs</code> does not contain a value</th>
              <td>destroys the contained value by calling <code>val-&gt;T::~T()</code></td>
              <td>no effect</td>
            </tr>
          </tbody>
  </table>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="14" id="optional.object.assign.14">
    
    <dt>Returns:</dt><dd><code>*this</code>.</dd>
  </cxx-returns>
        <cxx-postconditions para_num="15" id="optional.object.assign.15">
    
    <dt>Postconditions:</dt><dd><code>bool(<var>rhs</var>) == bool(*this)</code>.</dd>
  </cxx-postconditions>
        <cxx-remarks para_num="16" id="optional.object.assign.16">
    
    <dt>Remarks:</dt><dd>
          <p>The expression inside <code>noexcept</code> is equivalent to: </p><pre><code>is_nothrow_move_assignable_v&lt;T&gt; &amp;&amp; <w-br><wbr></w-br>is_nothrow_move_constructible_v&lt;T&gt;</code></pre><p></p>

          <p>
            If any exception is thrown, the result of the expression <code>bool(*this)</code> remains unchanged.
            If an exception is thrown during the call to <code>T</code>'s move constructor,
            the state of <code>*rhs.val</code> is determined by the exception safety guarantee of <code>T</code>'s move constructor.
            If an exception is thrown during the call to <code>T</code>'s move assignment,
            the state of <code><var>*val</var></code> and <code>*rhs.val</code> is determined by the exception safety guarantee of <code>T</code>'s move assignment.
          </p>
        </dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="17" id="optional.object.assign.17">
    
    <pre><code><cxx-signature>template &lt;class U&gt; optional&lt;T&gt;&amp; operator=(U&amp;&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="18" id="optional.object.assign.18">
    
    <dt>Requires:</dt><dd><code>is_constructible_v&lt;T, U&gt;</code> is <code>true</code> and <code>is_assignable_v&lt;T&amp;, U&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="19" id="optional.object.assign.19">
    
    <dt>Effects:</dt><dd>If <code>*this</code> contains a value, assigns <code>std::forward&lt;U&gt;(<var>v</var>)</code> to the contained value; otherwise initializes the contained value as if direct-non-list-initializing object of type <code>T</code> with <code>std::forward&lt;U&gt;(<var>v</var>)</code>.</dd>
  </cxx-effects>
        <cxx-returns para_num="20" id="optional.object.assign.20">
    
    <dt>Returns:</dt><dd><code>*this</code>.</dd>
  </cxx-returns>
        <cxx-postconditions para_num="21" id="optional.object.assign.21">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-remarks para_num="22" id="optional.object.assign.22">
    
    <dt>Remarks:</dt><dd>
          <p>If any exception is thrown, the result of the expression <code>bool(*this)</code> remains unchanged. If an exception is thrown during the call to <code>T</code>'s constructor, the state of <code><var>v</var></code> is determined by the exception safety guarantee of <code>T</code>'s constructor. If an exception is thrown during the call to <code>T</code>'s assignment, the state of <code><var>*val</var></code> and <code><var>v</var></code> is determined by the exception safety guarantee of <code>T</code>'s assignment.</p>
          <p>The function shall not participate in overload resolution unless
          <code>is_same_v&lt;decay_t&lt;U&gt;, T&gt;</code> is <code>true</code>.</p>
        </dd>
  </cxx-remarks>
        <cxx-notes para_num="23" id="optional.object.assign.23">
    
    <dt>Notes:</dt><dd>The reason for providing such generic assignment and then constraining it so that effectively <code>T</code> == <code>U</code> is to guarantee that assignment of the form <code>o = {}</code> is unambiguous.</dd>
  </cxx-notes>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="24" id="optional.object.assign.24">
    
    <pre><code><cxx-signature>template &lt;class... Args&gt; void emplace(Args&amp;&amp;... <var>args</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="25" id="optional.object.assign.25">
    
    <dt>Requires:</dt><dd><code>is_constructible_v&lt;T, Args&amp;&amp;...&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="26" id="optional.object.assign.26">
    
    <dt>Effects:</dt><dd>Calls <code>*this = nullopt</code>. Then initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with the arguments <code>std::forward&lt;Args&gt;(<var>args</var>)...</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="27" id="optional.object.assign.27">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="28" id="optional.object.assign.28">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="29" id="optional.object.assign.29">
    
    <dt>Remarks:</dt><dd>If an exception is thrown during the call to <code>T</code>'s constructor, <code>*this</code> does not contain a value, and the previous <code><var>*val</var></code> (if any) has been destroyed.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="30" id="optional.object.assign.30">
    
    <pre><code><cxx-signature>template &lt;class U, class... Args&gt; <w-br><wbr></w-br>void emplace(initializer_list&lt;U&gt; <var>il</var>, Args&amp;&amp;... <var>args</var>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="31" id="optional.object.assign.31">
    
    <dt>Effects:</dt><dd>Calls <code>*this = nullopt</code>. Then initializes the contained value as if direct-non-list-initializing an object of type <code>T</code> with the arguments <code><var>il</var>, std::forward&lt;Args&gt;(<var>args</var>)...</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="32" id="optional.object.assign.32">
    
    <dt>Postconditions:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-postconditions>
        <cxx-throws para_num="33" id="optional.object.assign.33">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
        <cxx-remarks para_num="34" id="optional.object.assign.34">
    
    <dt>Remarks:</dt><dd>
          <p>If an exception is thrown during the call to <code>T</code>'s constructor, <code>*this</code> does not contain a value, and the previous <code><var>*val</var></code> (if any) has been destroyed.</p>
          <p>The function shall not participate in overload resolution unless <code>is_constructible_v&lt;T, initializer_list&lt;U&gt;&amp;, Args&amp;&amp;...&gt;</code> is <code>true</code>.</p>
        </dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="optional.object.swap">
    

    <section>
      <header><span class="section-number">5.3.4</span> <h1 data-bookmark-label="5.3.4 Swap">Swap</h1> <span style="float:right"><a href="#optional.object.swap">[optional.object.swap]</a></span></header>
      
      

      <cxx-function para_num="1" id="optional.object.swap.1">
    
    <pre><code><cxx-signature>void swap(optional&lt;T&gt;&amp; <var>rhs</var>) noexcept(<em>see below</em>);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="optional.object.swap.2">
    
    <dt>Requires:</dt><dd>Lvalues of type <code>T</code> shall be swappable and <code>is_move_constructible_v&lt;T&gt;</code> is <code>true</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="3" id="optional.object.swap.3">
    
    <dt>Effects:</dt><dd>

          <table is="cxx-table" class="single-border column-rules">
    

    <caption>Table 6 — <wbr><span><code>optional::swap(optional&amp;)</code> effects</span></caption>
    
            
            <tbody><tr>
              <th></th>
              <th><code>*this</code> contains a value</th>
              <th><code>*this</code> does not contain a value</th>
            </tr>
            <tr>
              <th><code>rhs</code> contains a value</th>
              <td>calls <code>swap(*(*this), *<var>rhs</var>)</code></td>
              <td>initializes the contained value of <code>*this</code> as if
              direct-non-list-initializing an object of type <code>T</code> with the expression <code>std::move(*<var>rhs</var>)</code>,
              followed by <code>rhs.val-&gt;T::~T()</code>;
              postcondition is that <code>*this</code> contains a value and <code><var>rhs</var></code> does not contain a value</td>
            </tr>
              <tr><th><code>rhs</code> does not contain a value</th>
              <td>initializes the contained value of <code><var>rhs</var></code> as if
              direct-non-list-initializing an object of type <code>T</code> with the expression <code>std::move(*(*this))</code>,
              followed by <code>val-&gt;T::~T()</code>;
              postcondition is that <code>*this</code> does not contain a value and <code><var>rhs</var></code> contains a value</td>
              <td>no effect</td>
            </tr>
          </tbody>
  </table>
        </dd>
  </cxx-effects>
        <cxx-throws para_num="4" id="optional.object.swap.4">
    
    <dt>Throws:</dt><dd>Any exceptions that the expressions in the Effects element throw.</dd>
  </cxx-throws>
        <cxx-remarks para_num="5" id="optional.object.swap.5">
    
    <dt>Remarks:</dt><dd>
          <p>The expression inside <code>noexcept</code> is equivalent to: </p><pre><code>is_nothrow_move_constructible_v&lt;T&gt; &amp;&amp; <w-br><wbr></w-br>noexcept(swap(declval&lt;T&amp;&gt;(), declval&lt;T&amp;&gt;()))</code></pre><p></p>
          <p>
            If any exception is thrown, the results of the expressions <code>bool(*this)</code> and <code>bool(<var>rhs</var>)</code> remain unchanged.
            If an exception is thrown during the call to function <code>swap</code>
            the state of <code><var>*val</var></code> and <code>*rhs.val</code> is determined by the exception safety guarantee of <code>swap</code> for lvalues of <code>T</code>.
            If an exception is thrown during the call to <code>T</code>'s move constructor,
            the state of <code><var>*val</var></code> and <code>*rhs.val</code> is determined by the exception safety guarantee of <code>T</code>'s move constructor.
          </p>
        </dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="optional.object.observe">
    

    <section>
      <header><span class="section-number">5.3.5</span> <h1 data-bookmark-label="5.3.5 Observers">Observers</h1> <span style="float:right"><a href="#optional.object.observe">[optional.object.observe]</a></span></header>
      
      

      <cxx-function para_num="1" id="optional.object.observe.1">
    
    <pre><code><cxx-signature>constexpr T const* operator-&gt;() const;</cxx-signature><cxx-signature>constexpr T* operator-&gt;();</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-requires para_num="2" id="optional.object.observe.2">
    
    <dt>Requires:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-requires>
        <cxx-returns para_num="3" id="optional.object.observe.3">
    
    <dt>Returns:</dt><dd><code><var>val</var></code>.</dd>
  </cxx-returns>
        <cxx-throws para_num="4" id="optional.object.observe.4">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
        <cxx-remarks para_num="5" id="optional.object.observe.5">
    
    <dt>Remarks:</dt><dd>Unless <code>T</code> is a user-defined type with overloaded unary <code>operator&amp;</code>, these functions shall be <code>constexpr</code> functions.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="optional.object.observe.6">
    
    <pre><code><cxx-signature>constexpr T const&amp; operator*() const &amp;;</cxx-signature><cxx-signature>constexpr T&amp; operator*() &amp;;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-requires para_num="7" id="optional.object.observe.7">
    
    <dt>Requires:</dt><dd><code>*this</code> contains a value.</dd>
  </cxx-requires>
        <cxx-returns para_num="8" id="optional.object.observe.8">
    
    <dt>Returns:</dt><dd><code>*<var>val</var></code>.</dd>
  </cxx-returns>
        <cxx-throws para_num="9" id="optional.object.observe.9">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
        <cxx-remarks para_num="10" id="optional.object.observe.10">
    
    <dt>Remarks:</dt><dd>These functions shall be <code>constexpr</code> functions.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="11" id="optional.object.observe.11">
    
    <pre><code><cxx-signature>constexpr T&amp;&amp; operator*() &amp;&amp;;</cxx-signature><cxx-signature>constexpr const T&amp;&amp; operator*() const &amp;&amp;;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-requires para_num="12" id="optional.object.observe.12">
    
    <dt>Requires:</dt><dd><code>*this</code> contains a value</dd>
  </cxx-requires>
        <cxx-effects para_num="13" id="optional.object.observe.13">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return std::move(*<var>val</var>);</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="14" id="optional.object.observe.14">
    
    <pre><code><cxx-signature>constexpr explicit operator bool() const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="15" id="optional.object.observe.15">
    
    <dt>Returns:</dt><dd><code>true</code> if and only if <code>*this</code> contains a value.</dd>
  </cxx-returns>
        <cxx-remarks para_num="16" id="optional.object.observe.16">
    
    <dt>Remarks:</dt><dd>This function shall be a <code>constexpr</code> function.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="17" id="optional.object.observe.17">
    
    <pre><code><cxx-signature>constexpr T const&amp; value() const &amp;;</cxx-signature><cxx-signature>constexpr T&amp; value() &amp;;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-effects para_num="18" id="optional.object.observe.18">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return bool(*this) ? *val : throw bad_optional_access();</code>
      </dd>
  </cxx-effects>
    </dl>
  </cxx-function>

      <cxx-function para_num="19" id="optional.object.observe.19">
    
    <pre><code><cxx-signature>constexpr T&amp;&amp; value() &amp;&amp;;</cxx-signature><cxx-signature>constexpr const T&amp;&amp; value() const &amp;&amp;;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-effects para_num="20" id="optional.object.observe.20">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return bool(*this) ? std::move(*val) : throw bad_optional_access();</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="21" id="optional.object.observe.21">
    
    <pre><code><cxx-signature>template &lt;class U&gt; constexpr T value_or(U&amp;&amp; <var>v</var>) const &amp;;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="22" id="optional.object.observe.22">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return bool(*this) ? **this : static_cast&lt;T&gt;(std::forward&lt;U&gt;(<var>v</var>))</code>.</dd>
  </cxx-effects>
        <cxx-remarks para_num="23" id="optional.object.observe.23">
    
    <dt>Remarks:</dt><dd>If <code>is_copy_constructible_v&lt;T&gt; &amp;&amp; <w-br><wbr></w-br>is_convertible_v&lt;U&amp;&amp;, T&gt;</code> is <code>false</code>,
        the program is ill-formed.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="24" id="optional.object.observe.24">
    
    <pre><code><cxx-signature>template &lt;class U&gt; T value_or(U&amp;&amp; <var>v</var>) &amp;&amp;;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="25" id="optional.object.observe.25">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return bool(*this) ? <w-br><wbr></w-br>std::move(**this) : <w-br><wbr></w-br>static_cast&lt;T&gt;(std::forward&lt;U&gt;(<var>v</var>))</code>.</dd>
  </cxx-effects>
        <cxx-remarks para_num="26" id="optional.object.observe.26">
    
    <dt>Remarks:</dt><dd>If <code>is_move_constructible_v&lt;T&gt; &amp;&amp; <w-br><wbr></w-br>is_convertible_v&lt;U&amp;&amp;, T&gt;</code> is <code>false</code>,
        the program is ill-formed.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.inplace">
    

    <section>
      <header><span class="section-number">5.4</span> <h1 data-bookmark-label="5.4 In-place construction">In-place construction</h1> <span style="float:right"><a href="#optional.inplace">[optional.inplace]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.inplace.1">
    
    <pre><code><cxx-signature>struct in_place_t{};</cxx-signature><cxx-signature>constexpr in_place_t in_place{};</cxx-signature></code></pre>

    <dl>
      
      
      
    
    </dl>
  </cxx-function>

    <p para_num="2" id="optional.inplace.2">
      The struct <code>in_place_t</code> is an empty structure type used as a unique type to disambiguate constructor and function overloading.
      Specifically, <code>optional&lt;T&gt;</code> has a constructor with <code>in_place_t</code> as the first parameter followed by a parameter pack;
      this indicates that <code>T</code> should be constructed in-place (as if by a call to a placement new expression) with the forwarded pack expansion as arguments for the initialization of <code>T</code>.
    </p>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.nullopt">
    

    <section>
      <header><span class="section-number">5.5</span> <h1 data-bookmark-label="5.5 No-value state indicator">No-value state indicator</h1> <span style="float:right"><a href="#optional.nullopt">[optional.nullopt]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.nullopt.1">
    
    <pre><code><cxx-signature>struct nullopt_t{<em>see below</em>};</cxx-signature><cxx-signature>constexpr nullopt_t nullopt(<em>unspecified</em>);</cxx-signature></code></pre>

    <dl>
      
      
      
    
    </dl>
  </cxx-function>

    <p para_num="2" id="optional.nullopt.2">The struct <code>nullopt_t</code> is an empty structure type used as a unique type to indicate the state of not containing a value for <code>optional</code> objects.
    In particular, <code>optional&lt;T&gt;</code> has a constructor with <code>nullopt_t</code> as a single argument;
    this indicates that an optional object not containing a value shall be constructed.
    </p>

    <p para_num="3" id="optional.nullopt.3">Type <code>nullopt_t</code> shall not have a default constructor. It shall be a literal type. Constant <code>nullopt</code> shall be initialized with an argument of literal type.</p>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.bad_optional_access">
    

    <section>
      <header><span class="section-number">5.6</span> <h1 data-bookmark-label="5.6 Class bad_optional_access">Class <code>bad_optional_access</code></h1> <span style="float:right"><a href="#optional.bad_optional_access">[optional.bad_optional_access]</a></span></header>
      
    

<pre><code>class bad_optional_access : public logic_error {
public:
  bad_optional_access();
};</code></pre>

    <p para_num="1" id="optional.bad_optional_access.1">The class <code>bad_optional_access</code> defines the type of objects thrown as exceptions to report the situation where an attempt is made to access the value of an optional object that does not contain a value.</p>

    <cxx-function para_num="2" id="optional.bad_optional_access.2">
    
    <pre><code><cxx-signature>bad_optional_access();</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="3" id="optional.bad_optional_access.3">
    
    <dt>Effects:</dt><dd>Constructs an object of class <code>bad_optional_access</code>.</dd>
  </cxx-effects>
      <cxx-postconditions para_num="4" id="optional.bad_optional_access.4">
    
    <dt>Postconditions:</dt><dd><code>what()</code> returns an implementation-defined NTBS.</dd>
  </cxx-postconditions>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.relops">
    

    <section>
      <header><span class="section-number">5.7</span> <h1 data-bookmark-label="5.7 Relational operators">Relational operators</h1> <span style="float:right"><a href="#optional.relops">[optional.relops]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.relops.1">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp; <var>x</var>, const optional&lt;T&gt;&amp; <var>y</var>);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="2" id="optional.relops.2">
    
    <dt>Requires:</dt><dd><code>T</code> shall meet the requirements of <code>EqualityComparable</code>.</dd>
  </cxx-requires>
      <cxx-returns para_num="3" id="optional.relops.3">
    
    <dt>Returns:</dt><dd>If <code>bool(<var>x</var>) != bool(<var>y</var>)</code>, <code>false</code>; otherwise if <code>bool(<var>x</var>) == false</code>, <code>true</code>; otherwise <code>*<var>x</var> == *<var>y</var></code>.</dd>
  </cxx-returns>
      <cxx-remarks para_num="4" id="optional.relops.4">
    
    <dt>Remarks:</dt><dd>Specializations of this function template,
      for which <code>*<var>x</var> == *<var>y</var></code> is a core constant expression,
      shall be <code>constexpr</code> functions.</dd>
  </cxx-remarks>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="5" id="optional.relops.5">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp; x, const optional&lt;T&gt;&amp; y);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="6" id="optional.relops.6">
    
    <dt>Returns:</dt><dd><code>!(x == y)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="optional.relops.7">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp; <var>x</var>, const optional&lt;T&gt;&amp; <var>y</var>);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="8" id="optional.relops.8">
    
    <dt>Requires:</dt><dd><code>*<var>x</var> &lt; *<var>y</var></code> shall be well-formed
      and its result shall be convertible to <code>bool</code>.</dd>
  </cxx-requires>
      <cxx-returns para_num="9" id="optional.relops.9">
    
    <dt>Returns:</dt><dd>If <code>!<var>y</var></code>, <code>false</code>;
      otherwise, if <code>!<var>x</var></code>, <code>true</code>;
      otherwise <code>*<var>x</var> &lt; *<var>y</var></code>.</dd>
  </cxx-returns>
      <cxx-remarks para_num="10" id="optional.relops.10">
    
    <dt>Remarks:</dt><dd>Specializations of this function template,
      for which <code>*<var>x</var> &lt; *<var>y</var></code> is a core constant expression,
      shall be <code>constexpr</code> functions.</dd>
  </cxx-remarks>
    
    </dl>
  </cxx-function>


    <cxx-function para_num="11" id="optional.relops.11">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp; x, const optional&lt;T&gt;&amp; y);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="12" id="optional.relops.12">
    
    <dt>Returns:</dt><dd><code>y &lt; x</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="13" id="optional.relops.13">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp; x, const optional&lt;T&gt;&amp; y);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="14" id="optional.relops.14">
    
    <dt>Returns:</dt><dd><code>!(y &lt; x)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="15" id="optional.relops.15">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp; x, const optional&lt;T&gt;&amp; y);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="16" id="optional.relops.16">
    
    <dt>Returns:</dt><dd><code>!(x &lt; y)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.nullops">
    

    <section>
      <header><span class="section-number">5.8</span> <h1 data-bookmark-label="5.8 Comparison with nullopt">Comparison with <code>nullopt</code></h1> <span style="float:right"><a href="#optional.nullops">[optional.nullops]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.nullops.1">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp; <var>x</var>, nullopt_t) noexcept;</cxx-signature><cxx-signature>template &lt;class T&gt; constexpr bool operator==(nullopt_t, const optional&lt;T&gt;&amp; <var>x</var>) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      

      <cxx-returns para_num="2" id="optional.nullops.2">
    
    <dt>Returns:</dt><dd><code>!<var>x</var></code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="3" id="optional.nullops.3">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp; <var>x</var>, nullopt_t) noexcept;</cxx-signature><cxx-signature>template &lt;class T&gt; constexpr bool operator!=(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      

      <cxx-returns para_num="4" id="optional.nullops.4">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="5" id="optional.nullops.5">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp; <var>x</var>, nullopt_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="6" id="optional.nullops.6">
    
    <dt>Returns:</dt><dd><code>false</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="optional.nullops.7">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;(nullopt_t, const optional&lt;T&gt;&amp; <var>x</var>) noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="8" id="optional.nullops.8">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="9" id="optional.nullops.9">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp; <var>x</var>, nullopt_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="10" id="optional.nullops.10">
    
    <dt>Returns:</dt><dd><code>!<var>x</var></code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="11" id="optional.nullops.11">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;=(nullopt_t, const optional&lt;T&gt;&amp; <var>x</var>) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="12" id="optional.nullops.12">
    
    <dt>Returns:</dt><dd><code>true</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="13" id="optional.nullops.13">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp; <var>x</var>, nullopt_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="14" id="optional.nullops.14">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="15" id="optional.nullops.15">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;(nullopt_t, const optional&lt;T&gt;&amp; <var>x</var>) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="16" id="optional.nullops.16">
    
    <dt>Returns:</dt><dd><code>false</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="17" id="optional.nullops.17">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp; <var>x</var>, nullopt_t) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="18" id="optional.nullops.18">
    
    <dt>Returns:</dt><dd><code>true</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="19" id="optional.nullops.19">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;=(nullopt_t, const optional&lt;T&gt;&amp; <var>x</var>) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="20" id="optional.nullops.20">
    
    <dt>Returns:</dt><dd><code>!<var>x</var></code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.comp_with_t">
    

    <section>
      <header><span class="section-number">5.9</span> <h1 data-bookmark-label="5.9 Comparison with T">Comparison with <code>T</code></h1> <span style="float:right"><a href="#optional.comp_with_t">[optional.comp_with_t]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.comp_with_t.1">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp; <var>x</var>, const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="2" id="optional.comp_with_t.2">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? *<var>x</var> == <var>v</var> : false</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="3" id="optional.comp_with_t.3">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator==(const T&amp; <var>v</var>, const optional&lt;T&gt;&amp; x);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="4" id="optional.comp_with_t.4">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? <var>v</var> == *<var>x</var> : false</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="5" id="optional.comp_with_t.5">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp; <var>x</var>, const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="6" id="optional.comp_with_t.6">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? !(*<var>x</var> == <var>v</var>) : true</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="optional.comp_with_t.7">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator!=(const T&amp; <var>v</var>, const optional&lt;T&gt;&amp; x);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="8" id="optional.comp_with_t.8">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? !(<var>v</var> == *<var>x</var>) : true</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="9" id="optional.comp_with_t.9">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp; <var>x</var>, const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="10" id="optional.comp_with_t.10">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? *<var>x</var> &lt; <var>v</var> : true</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="11" id="optional.comp_with_t.11">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;(const T&amp; <var>v</var>, const optional&lt;T&gt;&amp; <var>x</var>);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="12" id="optional.comp_with_t.12">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? <var>v</var> &lt; *<var>x</var> : false</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="13" id="optional.comp_with_t.13">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp; <var>x</var>, const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="14" id="optional.comp_with_t.14">
    
    <dt>Returns:</dt><dd><code>!(<var>x</var> &gt; <var>v</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="15" id="optional.comp_with_t.15">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&lt;=(const T&amp; <var>v</var>, const optional&lt;T&gt;&amp; x);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="16" id="optional.comp_with_t.16">
    
    <dt>Returns:</dt><dd><code>!(<var>v</var> &gt; <var>x</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="17" id="optional.comp_with_t.17">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp; <var>x</var>, const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="18" id="optional.comp_with_t.18">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? <var>v</var> &lt; *<var>x</var> : false</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="19" id="optional.comp_with_t.19">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;(const T&amp; <var>v</var>, const optional&lt;T&gt;&amp; x);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="20" id="optional.comp_with_t.20">
    
    <dt>Returns:</dt><dd><code>bool(<var>x</var>) ? *<var>x</var> &lt; <var>v</var> : true</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="21" id="optional.comp_with_t.21">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp; <var>x</var>, const T&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="22" id="optional.comp_with_t.22">
    
    <dt>Returns:</dt><dd><code>!(<var>x</var> &lt; <var>v</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="23" id="optional.comp_with_t.23">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr bool operator&gt;=(const T&amp; <var>v</var>, const optional&lt;T&gt;&amp; x);</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="24" id="optional.comp_with_t.24">
    
    <dt>Returns:</dt><dd><code>!(<var>v</var> &lt; <var>x</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.specalg">
    

    <section>
      <header><span class="section-number">5.10</span> <h1 data-bookmark-label="5.10 Specialized algorithms">Specialized algorithms</h1> <span style="float:right"><a href="#optional.specalg">[optional.specalg]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.specalg.1">
    
    <pre><code><cxx-signature>template &lt;class T&gt; void swap(optional&lt;T&gt;&amp; <var>x</var>, optional&lt;T&gt;&amp; <var>y</var>) noexcept(noexcept(<var>x</var>.swap(<var>y</var>)));</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="2" id="optional.specalg.2">
    
    <dt>Effects:</dt><dd>Calls <code><var>x</var>.swap(<var>y</var>)</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="3" id="optional.specalg.3">
    
    <pre><code><cxx-signature>template &lt;class T&gt; constexpr optional&lt;decay_t&lt;T&gt;&gt; make_optional(T&amp;&amp; <var>v</var>);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="4" id="optional.specalg.4">
    
    <dt>Returns:</dt><dd><code>optional&lt;decay_t&lt;T&gt;&gt;(std::forward&lt;T&gt;(<var>v</var>))</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="optional.hash">
    

    <section>
      <header><span class="section-number">5.11</span> <h1 data-bookmark-label="5.11 Hash support">Hash support</h1> <span style="float:right"><a href="#optional.hash">[optional.hash]</a></span></header>
      
    

    <cxx-function para_num="1" id="optional.hash.1">
    
    <pre><code><cxx-signature>template &lt;class T&gt; struct hash&lt;experimental::optional&lt;T&gt;&gt;;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="2" id="optional.hash.2">
    
    <dt>Requires:</dt><dd>The template specialization <code>hash&lt;T&gt;</code> shall meet the requirements of class template <code>hash</code> (<cxx-ref in="cxx" to="unord.hash">C++14 <span title="unord.hash">§20.9.12</span></cxx-ref>).
      The template specialization <code>hash&lt;optional&lt;T&gt;&gt;</code> shall meet the requirements of class template <code>hash</code>.
      For an object <code><var>o</var></code> of type <code>optional&lt;T&gt;</code>, if <code>bool(<var>o</var>) == true</code>,
      <code>hash&lt;optional&lt;T&gt;&gt;()(<var>o</var>)</code> shall evaluate to the same value as <code>hash&lt;T&gt;()(*<var>o</var>)</code>;
      otherwise it evaluates to an unspecified value.</dd>
  </cxx-requires>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="any">
    

    <section>
      <header><span class="section-number">6</span> <h1 data-bookmark-label="6 Class any">Class <code>any</code></h1> <span style="float:right"><a href="#any">[any]</a></span></header>
      
  

  <p para_num="1" id="any.1">
    This section describes components that C++ programs may use to perform operations on objects of a discriminated type.
  </p>

  <p para_num="2" id="any.2">
    <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The discriminated type may contain values of different types but does not attempt conversion between them,
    i.e. <code>5</code> is held strictly as an <code>int</code> and is not implicitly convertible either to <code>"5"</code> or to <code>5.0</code>.
    This indifference to interpretation but awareness of type effectively allows safe, generic containers of single values, with no scope for surprises from ambiguous conversions.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
  </p>

  <cxx-section id="any.synop">
    

    <section>
      <header><span class="section-number">6.1</span> <h1 data-bookmark-label="6.1 Header <experimental/any> synopsis">Header &lt;experimental/any&gt; synopsis</h1> <span style="float:right"><a href="#any.synop">[any.synop]</a></span></header>
      
    

    <pre><code>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:
    <cxx-ref insynopsis="" to="any.cons">// <i><a title="any.cons" href="#any.cons">6.3.1</a>, any construct/destruct</i></cxx-ref>
    any() noexcept;

    any(const any&amp; other);
    any(any&amp;&amp; other) noexcept;

    template &lt;class ValueType&gt;
      any(ValueType&amp;&amp; value);

    ~any();

    <cxx-ref insynopsis="" to="any.assign">// <i><a title="any.assign" href="#any.assign">6.3.2</a>, any assignments</i></cxx-ref>
    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);

    <cxx-ref insynopsis="" to="any.modifiers">// <i><a title="any.modifiers" href="#any.modifiers">6.3.3</a>, any modifiers</i></cxx-ref>
    void clear() noexcept;
    void swap(any&amp; rhs) noexcept;

    <cxx-ref insynopsis="" to="any.observers">// <i><a title="any.observers" href="#any.observers">6.3.4</a>, any observers</i></cxx-ref>
    bool empty() const noexcept;
    const type_info&amp; type() const noexcept;
  };

  <cxx-ref insynopsis="" to="any.nonmembers">// <i><a title="any.nonmembers" href="#any.nonmembers">6.4</a>, Non-member functions</i></cxx-ref>
  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</code></pre>
  
    </section>
  </cxx-section>

  <cxx-section id="any.bad_any_cast">
    

    <section>
      <header><span class="section-number">6.2</span> <h1 data-bookmark-label="6.2 Class bad_any_cast">Class <code>bad_any_cast</code></h1> <span style="float:right"><a href="#any.bad_any_cast">[any.bad_any_cast]</a></span></header>
      
    
    <p para_num="1" id="any.bad_any_cast.1">
      Objects of type <code>bad_any_cast</code> are thrown by a failed <code> any_cast</code>.
    </p>
  
    </section>
  </cxx-section>

  <cxx-section id="any.class">
    

    <section>
      <header><span class="section-number">6.3</span> <h1 data-bookmark-label="6.3 Class any">Class <code>any</code></h1> <span style="float:right"><a href="#any.class">[any.class]</a></span></header>
      
    

    <p para_num="1" id="any.class.1">
      An object of class <code>any</code> stores an instance of any type that satisfies the constructor requirements or is empty,
      and this is referred to as the <dfn>state</dfn> of the class <code>any</code> object.
      The stored instance is called the <dfn>contained object</dfn>.
      Two states are equivalent if they are either both empty or if both are not empty and if the contained objects are equivalent.
    </p>

    <p para_num="2" id="any.class.2">
      The non-member <code>any_cast</code> functions provide type-safe access to the contained object.
    </p>

    <p para_num="3" id="any.class.3">
      Implementations should avoid the use of dynamically allocated memory for a small contained object.
      <cxx-example class="inline">
    
    <span class="nowrap">[ <em>Example:</em></span>
    where the object constructed is holding only an int.
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>
      Such small-object optimization shall only be applied to types <code>T</code> for which
      <code>is_nothrow_move_constructible_v&lt;T&gt;</code> is true.
    </p>

    <cxx-section id="any.cons">
    

    <section>
      <header><span class="section-number">6.3.1</span> <h1 data-bookmark-label="6.3.1 any construct/destruct"><code>any</code> construct/destruct</h1> <span style="float:right"><a href="#any.cons">[any.cons]</a></span></header>
      
      

      <cxx-function para_num="1" id="any.cons.1">
    
    <pre><code><cxx-signature>any() noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-postconditions para_num="2" id="any.cons.2">
    
    <dt>Postconditions:</dt><dd><code>this-&gt;empty()</code></dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="any.cons.3">
    
    <pre><code><cxx-signature>any(const any&amp; other);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="4" id="any.cons.4">
    
    <dt>Effects:</dt><dd>Constructs an object of type <code>any</code> with an equivalent state as <code>other</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="5" id="any.cons.5">
    
    <dt>Throws:</dt><dd>Any exceptions arising from calling the selected constructor of the contained object.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="any.cons.6">
    
    <pre><code><cxx-signature>any(any&amp;&amp; other) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="7" id="any.cons.7">
    
    <dt>Effects:</dt><dd>Constructs an object of type <code>any</code> with a state equivalent to the original state of <code>other</code>.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="8" id="any.cons.8">
    
    <dt>Postconditions:</dt><dd><code>other</code> is left in a valid but otherwise unspecified state.</dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="9" id="any.cons.9">
    
    <pre><code><cxx-signature>template&lt;class ValueType&gt;
any(ValueType&amp;&amp; value);</cxx-signature></code></pre>

    <dl>
      
        

        <p para_num="10" id="any.cons.10">Let <code>T</code> be equal to <code>decay_t&lt;ValueType&gt;</code>.</p>
        <cxx-requires para_num="11" id="any.cons.11">
    
    <dt>Requires:</dt><dd><code>T</code> shall satisfy the <code>CopyConstructible</code> requirements.
        If <code>is_copy_constructible_v&lt;T&gt;</code> is false, the program is ill-formed.</dd>
  </cxx-requires>
        <cxx-effects para_num="12" id="any.cons.12">
    
    <dt>Effects:</dt><dd>Constructs an object of type <code>any</code> that contains an object of type <code>T</code> direct-initialized with <code>std::forward&lt;ValueType&gt;(value)</code>.</dd>
  </cxx-effects>
        <cxx-remarks para_num="13" id="any.cons.13">
    
    <dt>Remarks:</dt><dd>This constructor shall not participate in overload resolution if <code>decay_t&lt;ValueType&gt;</code> is the same type as <code>any</code>.</dd>
  </cxx-remarks>
        <cxx-throws para_num="14" id="any.cons.14">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="15" id="any.cons.15">
    
    <pre><code><cxx-signature>~any();</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="16" id="any.cons.16">
    
    <dt>Effects:</dt><dd><code>clear()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="any.assign">
    

    <section>
      <header><span class="section-number">6.3.2</span> <h1 data-bookmark-label="6.3.2 any assignments"><code>any</code> assignments</h1> <span style="float:right"><a href="#any.assign">[any.assign]</a></span></header>
      
      

      <cxx-function para_num="1" id="any.assign.1">
    
    <pre><code><cxx-signature>any&amp; operator=(const any&amp; rhs);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="any.assign.2">
    
    <dt>Effects:</dt><dd><code>any(rhs).swap(*this)</code>.
        No effects if an exception is thrown.</dd>
  </cxx-effects>
        <cxx-returns para_num="3" id="any.assign.3">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
        <cxx-throws para_num="4" id="any.assign.4">
    
    <dt>Throws:</dt><dd>Any exceptions arising from the copy constructor of the contained object.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="any.assign.5">
    
    <pre><code><cxx-signature>any&amp; operator=(any&amp;&amp; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="6" id="any.assign.6">
    
    <dt>Effects:</dt><dd><code>any(std::move(rhs)).swap(*this)</code>.</dd>
  </cxx-effects>
        <cxx-returns para_num="7" id="any.assign.7">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
        <cxx-postconditions para_num="8" id="any.assign.8">
    
    <dt>Postconditions:</dt><dd>The state of <code>*this</code> is equivalent to the original state of <code>rhs</code>
        and <code>rhs</code> is left in a valid but otherwise unspecified state.</dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="9" id="any.assign.9">
    
    <pre><code><cxx-signature>template&lt;class ValueType&gt;
any&amp; operator=(ValueType&amp;&amp; rhs);</cxx-signature></code></pre>

    <dl>
      
        

        <p para_num="10" id="any.assign.10">Let <code>T</code> be equal to <code>decay_t&lt;ValueType&gt;</code>.</p>
        <cxx-requires para_num="11" id="any.assign.11">
    
    <dt>Requires:</dt><dd><code>T</code> shall satisfy the <code>CopyConstructible</code> requirements.
        If <code>is_copy_constructible_v&lt;T&gt;</code> is false, the program is ill-formed.</dd>
  </cxx-requires>
        <cxx-effects para_num="12" id="any.assign.12">
    
    <dt>Effects:</dt><dd>Constructs an object <code>tmp</code> of type <code>any</code> that contains an object of type <code>T</code> direct-initialized with <code>std::forward&lt;ValueType&gt;(rhs)</code>, and <code>tmp.swap(*this)</code>.
        No effects if an exception is thrown.</dd>
  </cxx-effects>
        <cxx-returns para_num="13" id="any.assign.13">
    
    <dt>Returns:</dt><dd><code>*this</code></dd>
  </cxx-returns>
        <cxx-remarks para_num="14" id="any.assign.14">
    
    <dt>Remarks:</dt><dd> This operator shall not participate in overload resolution if <code>decay_t&lt;ValueType&gt;</code> is the same type as <code>any</code>.</dd>
  </cxx-remarks>
        <cxx-throws para_num="15" id="any.assign.15">
    
    <dt>Throws:</dt><dd>Any exception thrown by the selected constructor of <code>T</code>.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="any.modifiers">
    

    <section>
      <header><span class="section-number">6.3.3</span> <h1 data-bookmark-label="6.3.3 any modifiers"><code>any</code> modifiers</h1> <span style="float:right"><a href="#any.modifiers">[any.modifiers]</a></span></header>
      
      

      <cxx-function para_num="1" id="any.modifiers.1">
    
    <pre><code><cxx-signature>void clear() noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="any.modifiers.2">
    
    <dt>Effects:</dt><dd>If not empty, destroys the contained object.</dd>
  </cxx-effects>
        <cxx-postconditions para_num="3" id="any.modifiers.3">
    
    <dt>Postconditions:</dt><dd><code>empty() == true</code>.</dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="4" id="any.modifiers.4">
    
    <pre><code><cxx-signature>void swap(any&amp; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="5" id="any.modifiers.5">
    
    <dt>Effects:</dt><dd>Exchange the states of <code>*this</code> and <code> rhs</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="any.observers">
    

    <section>
      <header><span class="section-number">6.3.4</span> <h1 data-bookmark-label="6.3.4 any observers"><code>any</code> observers</h1> <span style="float:right"><a href="#any.observers">[any.observers]</a></span></header>
      
      

      <cxx-function para_num="1" id="any.observers.1">
    
    <pre><code><cxx-signature>bool empty() const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="2" id="any.observers.2">
    
    <dt>Returns:</dt><dd><code>true</code> if <code>*this</code> has no contained object, otherwise <code> false</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="any.observers.3">
    
    <pre><code><cxx-signature>const type_info&amp; type() const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="4" id="any.observers.4">
    
    <dt>Returns:</dt><dd>If <code>*this</code> has a contained object of type T, <code>typeid(T)</code>;
        otherwise <code>typeid(void)</code>.</dd>
  </cxx-returns>
        <p para_num="5" id="any.observers.5"><cxx-note><span class="nowrap">[ <em>Note:</em></span>
    Useful for querying against types known either at compile time or only at runtime.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></p>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="any.nonmembers">
    

    <section>
      <header><span class="section-number">6.4</span> <h1 data-bookmark-label="6.4 Non-member functions"><a name="Non-member">Non-member</a> functions</h1> <span style="float:right"><a href="#any.nonmembers">[any.nonmembers]</a></span></header>
      
    

    <cxx-function para_num="1" id="any.nonmembers.1">
    
    <pre><code><cxx-signature>void swap(any&amp; x, any&amp; y) noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="2" id="any.nonmembers.2">
    
    <dt>Effects:</dt><dd><code>x.swap(y)</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="3" id="any.nonmembers.3">
    
    <pre><code><cxx-signature>template&lt;class ValueType&gt;
ValueType any_cast(const any&amp; operand);</cxx-signature><cxx-signature>template&lt;class ValueType&gt;
ValueType any_cast(any&amp; operand);</cxx-signature><cxx-signature>template&lt;class ValueType&gt;
ValueType any_cast(any&amp;&amp; operand);</cxx-signature></code></pre>

    <dl>
      
      
      
      

      <cxx-requires para_num="4" id="any.nonmembers.4">
    
    <dt>Requires:</dt><dd><code>is_reference_v&lt;ValueType&gt;</code> is true or <code>is_copy_constructible_v&lt;ValueType&gt;</code> is true.
      Otherwise the program is ill-formed.</dd>
  </cxx-requires>
      <cxx-returns para_num="5" id="any.nonmembers.5">
    
    <dt>Returns:</dt><dd>For the first form, <code>*any_cast&lt;add_const_t&lt;remove_reference_t&lt;ValueType&gt;&gt;&gt;(&amp;operand)</code>.
      For the second and third forms, <code>*any_cast&lt;remove_reference_t&lt;ValueType&gt;&gt;(&amp;operand)</code>.</dd>
  </cxx-returns>
      <cxx-throws para_num="6" id="any.nonmembers.6">
    
    <dt>Throws:</dt><dd><code>bad_any_cast</code> if <code>operand.type() != typeid(remove_reference_t&lt;ValueType&gt;)</code>.</dd>
  </cxx-throws>
      <cxx-example>
    
    <span class="nowrap">[ <em>Example:</em></span>
    
        <pre><code>any x(5);                                   // x holds int
assert(any_cast&lt;int&gt;(x) == 5);              // cast to value
any_cast&lt;int&amp;&gt;(x) = 10;                     // cast to reference
assert(any_cast&lt;int&gt;(x) == 10);

x = "Meow";                                 // x holds const char*
assert(strcmp(any_cast&lt;const char*&gt;(x), "Meow") == 0);
any_cast&lt;const char*&amp;&gt;(x) = "Harry";
assert(strcmp(any_cast&lt;const char*&gt;(x), "Harry") == 0);

x = string("Meow");                         // x holds string
string s, s2("Jane");
s = move(any_cast&lt;string&amp;&gt;(x));             // move from any
assert(s == "Meow");
any_cast&lt;string&amp;&gt;(x) = move(s2);            // move to any
assert(any_cast&lt;const string&amp;&gt;(x) == "Jane");

string cat("Meow");
const any y(cat);                           // const y holds string
assert(any_cast&lt;const string&amp;&gt;(y) == cat);

any_cast&lt;string&amp;&gt;(y);                       // error; cannot
                                            //  any_cast away const</code></pre>
      
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="any.nonmembers.7">
    
    <pre><code><cxx-signature>template&lt;class ValueType&gt;
const ValueType* any_cast(const any* operand) noexcept;</cxx-signature><cxx-signature>template&lt;class ValueType&gt;
ValueType* any_cast(any* operand) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      

      <cxx-returns para_num="8" id="any.nonmembers.8">
    
    <dt>Returns:</dt><dd>If <code>operand != nullptr &amp;&amp; <w-br><wbr></w-br>operand-&gt;type() == typeid(ValueType)</code>,
      a pointer to the object contained by <code>operand</code>,
      otherwise <code>nullptr</code>.</dd>
  </cxx-returns>
      <cxx-example>
    
    <span class="nowrap">[ <em>Example:</em></span>
    
        <pre><code>bool is_string(const any&amp; operand) {
  return any_cast&lt;string&gt;(&amp;operand) != nullptr;
}</code></pre>
      
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="string.view">
    

    <section>
      <header><span class="section-number">7</span> <h1 data-bookmark-label="7 string_view"><code>string_view</code></h1> <span style="float:right"><a href="#string.view">[string.view]</a></span></header>
      
  

  <p para_num="1" id="string.view.1">
    The class template <code>basic_string_view</code> describes an object that can refer to a constant contiguous sequence of char-like (<cxx-ref in="cxx" to="strings.general">C++14 <span title="strings.general">§21.1</span></cxx-ref>) objects with the first element of the sequence at position zero.
    In the rest of this section, the type of the char-like objects held in a <code>basic_string_view</code> object is designated by <code>charT</code>.
  </p>

  <p para_num="2" id="string.view.2">
    <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The library provides implicit conversions from <code>const charT*</code> and <code>std::basic_string&lt;charT, ...&gt;</code> to <code>std::basic_string_view&lt;charT, ...&gt;</code> so that user code can accept just <code>std::basic_string_view&lt;charT&gt;</code> as a non-templated parameter wherever a sequence of characters is expected.
    User-defined types should define their own implicit conversions to <code>std::basic_string_view</code> in order to interoperate with these functions.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
  </p>

  <p para_num="3" id="string.view.3">
    The complexity of <code>basic_string_view</code> member functions is O(1) unless otherwise specified.
  </p>

  <cxx-section id="string.view.synop">
    

    <section>
      <header><span class="section-number">7.1</span> <h1 data-bookmark-label="7.1 Header <experimental/string_view> synopsis">Header <code>&lt;experimental/string_view&gt;</code> synopsis</h1> <span style="float:right"><a href="#string.view.synop">[string.view.synop]</a></span></header>
      
    

    <pre><code>namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    <cxx-ref insynopsis="" to="string.view.template">// <i><a title="string.view.template" href="#string.view.template">7.2</a>, Class template basic_string_view</i></cxx-ref>
    template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;
        class basic_string_view;

    <cxx-ref insynopsis="" to="string.view.comparison">// <i><a title="string.view.comparison" href="#string.view.comparison">7.9</a>, basic_string_view non-member comparison functions</i></cxx-ref>
    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;
    // <i>see below</i>, sufficient additional overloads of comparison functions

    <cxx-ref insynopsis="" to="string.view.io">// <i><a title="string.view.io" href="#string.view.io">7.10</a>, Inserters and extractors</i></cxx-ref>
    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

  <cxx-ref insynopsis="" to="string.view.hash">// <i><a title="string.view.hash" href="#string.view.hash">7.11</a>, Hash support</i></cxx-ref>
  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</code></pre>

    <p para_num="1" id="string.view.synop.1">
      The function templates defined in <cxx-ref in="cxx" to="utility.swap">C++14 <span title="utility.swap">§20.2.2</span></cxx-ref> and <cxx-ref in="cxx" to="iterator.range">C++14 <span title="iterator.range">§24.7</span></cxx-ref> are available when <code>&lt;experimental/string_view&gt;</code> is included.
    </p>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.template">
    

    <section>
      <header><span class="section-number">7.2</span> <h1 data-bookmark-label="7.2 Class template basic_string_view">Class template <code>basic_string_view</code></h1> <span style="float:right"><a href="#string.view.template">[string.view.template]</a></span></header>
      
    

    <pre><code>template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;
class basic_string_view {
  public:
  // types
  typedef traits traits_type;
  typedef charT value_type;
  typedef charT* pointer;
  typedef const charT* const_pointer;
  typedef charT&amp; reference;
  typedef const charT&amp; const_reference;
  typedef <var>implementation-defined</var> const_iterator; // See <cxx-ref to="string.view.iterators"><a title="string.view.iterators" href="#string.view.iterators">7.4</a></cxx-ref>
  typedef const_iterator iterator;<cxx-footnote><!--
    Be sure not to introduce whitespace here, as it appears around the footnote.
  --><sup id="footnote-call-1"><a href="#footnote-body-1">1</a></sup><aside class="footnote" id="footnote-body-1"><span class="marker"><a href="#footnote-call-1">1</a>) </span>Because <code>basic_string_view</code> refers to a constant sequence, <code>iterator</code> and <code>const_iterator</code> are the same type.</aside></cxx-footnote>
  typedef reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
  typedef const_reverse_iterator reverse_iterator;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  static constexpr size_type npos = size_type(-1);

  <cxx-ref insynopsis="" to="string.view.cons">// <i><a title="string.view.cons" href="#string.view.cons">7.3</a>, basic_string_view constructors and assignment operators</i></cxx-ref>
  constexpr basic_string_view() noexcept;
  constexpr basic_string_view(const basic_string_view&amp;) noexcept = default;
  basic_string_view&amp; operator=(const basic_string_view&amp;) noexcept = default;
  template&lt;class Allocator&gt;
  basic_string_view(const basic_string&lt;charT, traits, Allocator&gt;&amp; str) noexcept;
  constexpr basic_string_view(const charT* str);
  constexpr basic_string_view(const charT* str, size_type len);

  <cxx-ref insynopsis="" to="string.view.iterators">// <i><a title="string.view.iterators" href="#string.view.iterators">7.4</a>, basic_string_view iterator support</i></cxx-ref>
  constexpr const_iterator begin() const noexcept;
  constexpr const_iterator end() const noexcept;
  constexpr const_iterator cbegin() const noexcept;
  constexpr const_iterator cend() const noexcept;
  const_reverse_iterator rbegin() const noexcept;
  const_reverse_iterator rend() const noexcept;
  const_reverse_iterator crbegin() const noexcept;
  const_reverse_iterator crend() const noexcept;

  <cxx-ref insynopsis="" to="string.view.capacity">// <i><a title="string.view.capacity" href="#string.view.capacity">7.5</a>, basic_string_view capacity</i></cxx-ref>
  constexpr size_type size() const noexcept;
  constexpr size_type length() const noexcept;
  constexpr size_type max_size() const noexcept;
  constexpr bool empty() const noexcept;

  <cxx-ref insynopsis="" to="string.view.access">// <i><a title="string.view.access" href="#string.view.access">7.6</a>, basic_string_view element access</i></cxx-ref>
  constexpr const_reference operator[](size_type pos) const;
  constexpr const_reference at(size_type pos) const;
  constexpr const_reference front() const;
  constexpr const_reference back() const;
  constexpr const_pointer data() const noexcept;

  <cxx-ref insynopsis="" to="string.view.modifiers">// <i><a title="string.view.modifiers" href="#string.view.modifiers">7.7</a>, basic_string_view modifiers</i></cxx-ref>
  constexpr void remove_prefix(size_type n);
  constexpr void remove_suffix(size_type n);
  constexpr void swap(basic_string_view&amp; s) noexcept;

  <cxx-ref insynopsis="" to="string.view.ops">// <i><a title="string.view.ops" href="#string.view.ops">7.8</a>, basic_string_view string operations</i></cxx-ref>
  template&lt;class Allocator&gt;
  explicit operator basic_string&lt;charT, traits, Allocator&gt;() const;
  template&lt;class Allocator = allocator&lt;charT&gt; &gt;
  basic_string&lt;charT, traits, Allocator&gt; to_string(
    const Allocator&amp; a = Allocator()) const;

  size_type copy(charT* s, size_type n, size_type pos = 0) const;

  constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
  constexpr int compare(basic_string_view s) const noexcept;
  constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
  constexpr int compare(size_type pos1, size_type n1,
                        basic_string_view s, size_type pos2, size_type n2) const;
  constexpr int compare(const charT* s) const;
  constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
  constexpr int compare(size_type pos1, size_type n1,
                        const charT* s, size_type n2) const;
  constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
  constexpr size_type find(charT c, size_type pos = 0) const noexcept;
  constexpr size_type find(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find(const charT* s, size_type pos = 0) const;
  constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
  constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
  constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
  constexpr size_type rfind(const charT* s, size_type pos = npos) const;
  constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
  constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
  constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
  constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
  constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
  constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
  constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
  constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
  constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
  constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
  constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
  constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;

 private:
  const_pointer data_;  // <em>exposition only</em>
  size_type     size_;  // <em>exposition only</em>
};</code></pre>

    <p para_num="1" id="string.view.template.1">
      In every specialization <code>basic_string_view&lt;charT, traits&gt;</code>, the type <code>traits</code> shall satisfy the character traits requirements (<cxx-ref in="cxx" to="char.traits">C++14 <span title="char.traits">§21.2</span></cxx-ref>),
      and the type <code>traits::char_type</code> shall name the same type as <code>charT</code>.
    </p>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.cons">
    

    <section>
      <header><span class="section-number">7.3</span> <h1 data-bookmark-label="7.3 basic_string_view constructors and assignment operators"><code>basic_string_view</code> constructors and assignment operators</h1> <span style="float:right"><a href="#string.view.cons">[string.view.cons]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.cons.1">
    
    <pre><code><cxx-signature>constexpr basic_string_view() noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="2" id="string.view.cons.2">
    
    <dt>Effects:</dt><dd>Constructs an empty <code>basic_string_view</code>.</dd>
  </cxx-effects>
      <cxx-postconditions para_num="3" id="string.view.cons.3">
    
    <dt>Postconditions:</dt><dd><code>size_ == 0</code> and <code>data_ == nullptr</code>.</dd>
  </cxx-postconditions>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="4" id="string.view.cons.4">
    
    <pre><code><cxx-signature>template&lt;class Allocator&gt;
basic_string_view(const basic_string&lt;charT, traits, Allocator&gt;&amp; str) noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="5" id="string.view.cons.5">
    
    <dt>Effects:</dt><dd>Constructs a <code>basic_string_view</code>, with the postconditions in <cxx-ref to="tab:string.view.ctr.1"><a title="tab:string.view.ctr.1" href="#tab:string.view.ctr.1">Table 7</a></cxx-ref>.</dd>
  </cxx-effects>
      <table is="cxx-table" id="tab:string.view.ctr.1">
    

    <caption>Table 7 — <wbr><span><code>basic_string_view(const basic_string&amp;)</code> effects</span></caption>
    
        
        <tbody><tr><th>Element</th><th>Value</th></tr>
        <tr><td><code>data_</code></td><td><code>str.data()</code></td></tr>
        <tr><td><code>size_</code></td><td><code>str.size()</code></td></tr>
      </tbody>
  </table>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="6" id="string.view.cons.6">
    
    <pre><code><cxx-signature>constexpr basic_string_view(const charT* str);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="7" id="string.view.cons.7">
    
    <dt>Requires:</dt><dd><cxx-range begin="str" end="str + traits::length(str)">[<code>str</code>, <code>str + traits::length(str)</code>)</cxx-range> is a valid range.</dd>
  </cxx-requires>
      <cxx-effects para_num="8" id="string.view.cons.8">
    
    <dt>Effects:</dt><dd>Constructs a <code>basic_string_view</code>, with the postconditions
      in <cxx-ref to="tab:string.view.ctr.2"><a title="tab:string.view.ctr.2" href="#tab:string.view.ctr.2">Table 8</a></cxx-ref>.</dd>
  </cxx-effects>

      <table is="cxx-table" id="tab:string.view.ctr.2">
    

    <caption>Table 8 — <wbr><span><code>basic_string_view(const charT*)<code> effects</code></code></span></caption>
    
      <tbody><tr><th>Element</th><th>Value</th></tr>
      <tr><td><code>data_</code></td><td><code>str</code></td></tr>
      <tr><td><code>size_</code></td><td><code>traits::length(str)</code></td></tr>
      </tbody>
  </table>

      <cxx-complexity para_num="9" id="string.view.cons.9">
    
    <dt>Complexity:</dt><dd>O(<code>traits::length(str)</code>)</dd>
  </cxx-complexity>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="10" id="string.view.cons.10">
    
    <pre><code><cxx-signature>constexpr basic_string_view(const charT* str, size_type len);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="11" id="string.view.cons.11">
    
    <dt>Requires:</dt><dd><cxx-range begin="str" end="str + len">[<code>str</code>, <code>str + len</code>)</cxx-range> is a valid range.</dd>
  </cxx-requires>
      <cxx-effects para_num="12" id="string.view.cons.12">
    
    <dt>Effects:</dt><dd>Constructs a <code>basic_string_view</code>, with the postconditions in <cxx-ref to="tab:string.view.ctr.3"><a title="tab:string.view.ctr.3" href="#tab:string.view.ctr.3">Table 9</a></cxx-ref>.</dd>
  </cxx-effects>
      <table is="cxx-table" id="tab:string.view.ctr.3">
    

    <caption>Table 9 — <wbr><span><code>basic_string_view(const charT*, size_type)</code> effects</span></caption>
    
        <tbody><tr><th>Element</th><th>Value</th></tr>
        <tr><td><code>data_</code></td><td><code>str</code></td></tr>
        <tr><td><code>size_</code></td><td><code>len</code></td></tr>
      </tbody>
  </table>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.iterators">
    

    <section>
      <header><span class="section-number">7.4</span> <h1 data-bookmark-label="7.4 basic_string_view iterator support"><code>basic_string_view</code> iterator support</h1> <span style="float:right"><a href="#string.view.iterators">[string.view.iterators]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.iterators.1">
    
    <pre><code><cxx-signature>typedef <var>implementation-defined</var> const_iterator;</cxx-signature></code></pre>

    <dl>
      
      

      <p para_num="2" id="string.view.iterators.2">
        A constant random-access iterator type such that, for a <code>const_iterator it</code>, if <code>&amp;*(it+N)</code> is valid, then it is equal to <code>(&amp;*it)+N</code>.
      </p>
      <p para_num="3" id="string.view.iterators.3">
        For a <code>basic_string_view str</code>, any operation that invalidates a pointer in the range <cxx-range begin="str.data()" end="str.data()+str.size()">[<code>str.data()</code>, <code>str.data()+str.size()</code>)</cxx-range> invalidates pointers, iterators, and references returned from <code>str</code>'s methods.
      </p>
      <p para_num="4" id="string.view.iterators.4">
        All requirements on container iterators (<cxx-ref in="cxx" to="container.requirements">C++14 <span title="container.requirements">§23.2</span></cxx-ref>) apply to <code>basic_string_view::const_iterator</code> as well.
      </p>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="5" id="string.view.iterators.5">
    
    <pre><code><cxx-signature>constexpr const_iterator begin() const noexcept;</cxx-signature><cxx-signature>constexpr const_iterator cbegin() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      
      <cxx-returns para_num="6" id="string.view.iterators.6">
    
    <dt>Returns:</dt><dd>An iterator such that <code>&amp;*begin() == data_</code> if <code>!empty()</code>,
      or else an unspecified value such that <cxx-range begin="begin()" end="end()">[<code>begin()</code>, <code>end()</code>)</cxx-range> is a valid range.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="string.view.iterators.7">
    
    <pre><code><cxx-signature>constexpr const_iterator end() const noexcept;</cxx-signature><cxx-signature>constexpr const_iterator cend() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      

      <cxx-returns para_num="8" id="string.view.iterators.8">
    
    <dt>Returns:</dt><dd> <code>begin() + size()</code></dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="9" id="string.view.iterators.9">
    
    <pre><code><cxx-signature>const_reverse_iterator rbegin() const noexcept;</cxx-signature><cxx-signature>const_reverse_iterator crbegin() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      

      <cxx-returns para_num="10" id="string.view.iterators.10">
    
    <dt>Returns:</dt><dd> <code>const_reverse_iterator(end())</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="11" id="string.view.iterators.11">
    
    <pre><code><cxx-signature>const_reverse_iterator rend() const noexcept;</cxx-signature><cxx-signature>const_reverse_iterator crend() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      

      <cxx-returns para_num="12" id="string.view.iterators.12">
    
    <dt>Returns:</dt><dd><code>const_reverse_iterator(begin())</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.capacity">
    

    <section>
      <header><span class="section-number">7.5</span> <h1 data-bookmark-label="7.5 basic_string_view capacity"><code>basic_string_view</code> capacity</h1> <span style="float:right"><a href="#string.view.capacity">[string.view.capacity]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.capacity.1">
    
    <pre><code><cxx-signature>constexpr size_type size() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="2" id="string.view.capacity.2">
    
    <dt>Returns:</dt><dd><code>size_</code></dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="3" id="string.view.capacity.3">
    
    <pre><code><cxx-signature>constexpr size_type length() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="4" id="string.view.capacity.4">
    
    <dt>Returns:</dt><dd><code>size_</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="5" id="string.view.capacity.5">
    
    <pre><code><cxx-signature>constexpr size_type max_size() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="6" id="string.view.capacity.6">
    
    <dt>Returns:</dt><dd>The largest possible number of char-like objects that can be referred to by a <code>basic_string_view</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="string.view.capacity.7">
    
    <pre><code><cxx-signature>constexpr bool empty() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="8" id="string.view.capacity.8">
    
    <dt>Returns:</dt><dd><code>size_ == 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.access">
    

    <section>
      <header><span class="section-number">7.6</span> <h1 data-bookmark-label="7.6 basic_string_view element access"><code>basic_string_view</code> element access</h1> <span style="float:right"><a href="#string.view.access">[string.view.access]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.access.1">
    
    <pre><code><cxx-signature>constexpr const_reference operator[](size_type pos) const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="2" id="string.view.access.2">
    
    <dt>Requires:</dt><dd><code>pos &lt; size()</code>.</dd>
  </cxx-requires>
      <cxx-returns para_num="3" id="string.view.access.3">
    
    <dt>Returns:</dt><dd><code>data_[pos]</code></dd>
  </cxx-returns>
      <cxx-throws para_num="4" id="string.view.access.4">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
      <p para_num="5" id="string.view.access.5"><cxx-note><span class="nowrap">[ <em>Note:</em></span>
    Unlike <code>basic_string::operator[]</code>,
        <code>basic_string_view::operator[](size())</code> has undefined behavior instead of returning <code>charT()</code>.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></p>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="6" id="string.view.access.6">
    
    <pre><code><cxx-signature>constexpr const_reference at(size_type pos) const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-throws para_num="7" id="string.view.access.7">
    
    <dt>Throws:</dt><dd><code>out_of_range</code> if <code>pos &gt;= size()</code>.</dd>
  </cxx-throws>
      <cxx-returns para_num="8" id="string.view.access.8">
    
    <dt>Returns:</dt><dd><code>data_[pos]</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="9" id="string.view.access.9">
    
    <pre><code><cxx-signature>constexpr const_reference front() const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="10" id="string.view.access.10">
    
    <dt>Requires:</dt><dd><code>!empty()</code></dd>
  </cxx-requires>
      <cxx-returns para_num="11" id="string.view.access.11">
    
    <dt>Returns:</dt><dd><code>data_[0]</code>.</dd>
  </cxx-returns>
      <cxx-throws para_num="12" id="string.view.access.12">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="13" id="string.view.access.13">
    
    <pre><code><cxx-signature>constexpr const_reference back() const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="14" id="string.view.access.14">
    
    <dt>Requires:</dt><dd><code>!empty()</code></dd>
  </cxx-requires>
      <cxx-returns para_num="15" id="string.view.access.15">
    
    <dt>Returns:</dt><dd><code>data_[size() - 1]</code>.</dd>
  </cxx-returns>
      <cxx-throws para_num="16" id="string.view.access.16">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="17" id="string.view.access.17">
    
    <pre><code><cxx-signature>constexpr const_pointer data() const noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="18" id="string.view.access.18">
    
    <dt>Returns:</dt><dd><code>data_</code></dd>
  </cxx-returns>
      <p para_num="19" id="string.view.access.19"><cxx-note><span class="nowrap">[ <em>Note:</em></span>
    Unlike <code>basic_string::data()</code> and string literals,
      <code>data()</code> may return a pointer to a buffer that is not null-terminated.
      Therefore it is typically a mistake to pass <code>data()</code> to a routine that takes just a <code>const charT*</code> and expects a null-terminated string.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></p>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.modifiers">
    

    <section>
      <header><span class="section-number">7.7</span> <h1 data-bookmark-label="7.7 basic_string_view modifiers"><code>basic_string_view</code> modifiers</h1> <span style="float:right"><a href="#string.view.modifiers">[string.view.modifiers]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.modifiers.1">
    
    <pre><code><cxx-signature>constexpr void remove_prefix(size_type n);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="2" id="string.view.modifiers.2">
    
    <dt>Requires:</dt><dd><code>n &lt;= size()</code></dd>
  </cxx-requires>
      <cxx-effects para_num="3" id="string.view.modifiers.3">
    
    <dt>Effects:</dt><dd>Equivalent to <code>data_ += n; size_ -= n;</code></dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="4" id="string.view.modifiers.4">
    
    <pre><code><cxx-signature>constexpr void remove_suffix(size_type n);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-requires para_num="5" id="string.view.modifiers.5">
    
    <dt>Requires:</dt><dd><code>n &lt;= size()</code></dd>
  </cxx-requires>
      <cxx-effects para_num="6" id="string.view.modifiers.6">
    
    <dt>Effects:</dt><dd>Equivalent to <code>size_ -= n;</code></dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="7" id="string.view.modifiers.7">
    
    <pre><code><cxx-signature>constexpr void swap(basic_string_view&amp; s) noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="8" id="string.view.modifiers.8">
    
    <dt>Effects:</dt><dd>Exchanges the values of <code>*this</code> and <code>s</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.ops">
    

    <section>
      <header><span class="section-number">7.8</span> <h1 data-bookmark-label="7.8 basic_string_view string operations"><code>basic_string_view</code> string operations</h1> <span style="float:right"><a href="#string.view.ops">[string.view.ops]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.ops.1">
    
    <pre><code><cxx-signature>template&lt;class Allocator&gt;
explicit<cxx-footnote><!--
    Be sure not to introduce whitespace here, as it appears around the footnote.
  --><sup id="footnote-call-2"><a href="#footnote-body-2">2</a></sup><aside class="footnote" id="footnote-body-2"><span class="marker"><a href="#footnote-call-2">2</a>) </span>This conversion is explicit to avoid accidental O(N) operations on type mismatches.</aside></cxx-footnote> operator basic_string&lt;
    charT, traits, Allocator&gt;() const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="2" id="string.view.ops.2">
    
    <dt>Effects:</dt><dd>Equivalent to <code>basic_string&lt;charT, traits, Allocator&gt;(begin(), end()).</code></dd>
  </cxx-effects>
      <cxx-complexity para_num="3" id="string.view.ops.3">
    
    <dt>Complexity:</dt><dd>O(<code>size()</code>)</dd>
  </cxx-complexity>
      <p para_num="4" id="string.view.ops.4"><cxx-note><span class="nowrap">[ <em>Note:</em></span>
    Users who want to control the allocator instance should call <code>to_string(allocator)</code>.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></p>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="5" id="string.view.ops.5">
    
    <pre><code><cxx-signature>template&lt;class Allocator = allocator&lt;charT&gt;&gt;
basic_string&lt;charT, traits, Allocator&gt; to_string(
    const Allocator&amp; a = Allocator()) const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="6" id="string.view.ops.6">
    
    <dt>Returns:</dt><dd><code>basic_string&lt;charT, traits, Allocator&gt;(begin(), end(), a)</code>.</dd>
  </cxx-returns>
      <cxx-complexity para_num="7" id="string.view.ops.7">
    
    <dt>Complexity:</dt><dd>O(<code>size()</code>)</dd>
  </cxx-complexity>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="8" id="string.view.ops.8">
    
    <pre><code><cxx-signature>size_type copy(charT* s, size_type n, size_type pos = 0) const;</cxx-signature></code></pre>

    <dl>
      
      

      <p para_num="9" id="string.view.ops.9">Let <code>rlen</code> be the smaller of <code>n</code> and <code>size() - pos</code>.</p>
      <cxx-throws para_num="10" id="string.view.ops.10">
    
    <dt>Throws:</dt><dd><code>out_of_range</code> if <code>pos &gt; size()</code>.</dd>
  </cxx-throws>
      <cxx-requires para_num="11" id="string.view.ops.11">
    
    <dt>Requires:</dt><dd><cxx-range begin="s" end="s + rlen">[<code>s</code>, <code>s + rlen</code>)</cxx-range> is a valid range.</dd>
  </cxx-requires>
      <cxx-effects para_num="12" id="string.view.ops.12">
    
    <dt>Effects:</dt><dd>Equivalent to <code>std::copy_n(begin() + pos, rlen, s).</code></dd>
  </cxx-effects>
      <cxx-returns para_num="13" id="string.view.ops.13">
    
    <dt>Returns:</dt><dd><code>rlen</code>.</dd>
  </cxx-returns>
      <cxx-complexity para_num="14" id="string.view.ops.14">
    
    <dt>Complexity:</dt><dd>O(<code>rlen</code>)</dd>
  </cxx-complexity>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="15" id="string.view.ops.15">
    
    <pre><code><cxx-signature>constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-throws para_num="16" id="string.view.ops.16">
    
    <dt>Throws:</dt><dd><code>out_of_range</code> if <code>pos &gt; size()</code>.</dd>
  </cxx-throws>
      <cxx-effects para_num="17" id="string.view.ops.17">
    
    <dt>Effects:</dt><dd>Determines the effective length <code><var>rlen</var></code> of the string to reference as the smaller of <code>n</code> and <code>size() - pos</code>.</dd>
  </cxx-effects>
      <cxx-returns para_num="18" id="string.view.ops.18">
    
    <dt>Returns:</dt><dd><code>basic_string_view(data()+pos, <var>rlen</var>)</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="19" id="string.view.ops.19">
    
    <pre><code><cxx-signature>constexpr int compare(basic_string_view str) const noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="20" id="string.view.ops.20">
    
    <dt>Effects:</dt><dd>Determines the effective length <code><var>rlen</var></code> of the strings to compare as the smaller of <code>size()</code> and <code>str.size()</code>.
        The function then compares the two strings by calling <code>traits::compare(data(), str.data(), <var>rlen</var>)</code>.</dd>
  </cxx-effects>
      <cxx-complexity para_num="21" id="string.view.ops.21">
    
    <dt>Complexity:</dt><dd>O(<code><var>rlen</var></code>)</dd>
  </cxx-complexity>
      <cxx-returns para_num="22" id="string.view.ops.22">
    
    <dt>Returns:</dt><dd>The nonzero result if the result of the comparison is nonzero.
        Otherwise, returns a value as indicated in <cxx-ref to="tab:string.view.compare"><a title="tab:string.view.compare" href="#tab:string.view.compare">Table 10</a></cxx-ref>.</dd>
  </cxx-returns>
      <table is="cxx-table" id="tab:string.view.compare" class="center">
    

    <caption>Table 10 — <wbr><span><code>compare()</code> results</span></caption>
    
        
        <tbody><tr><th>Condition</th><th>Return Value</th></tr>
        <tr><td><code>size() &lt; str.size()</code></td><td><code>&lt; 0</code></td></tr>
        <tr><td><code>size() == str.size()</code></td><td><code>&nbsp; 0</code></td></tr>
        <tr><td><code>size() &gt;  str.size()</code></td><td><code>&gt; 0</code></td></tr>
      </tbody>
  </table>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="23" id="string.view.ops.23">
    
    <pre><code><cxx-signature>constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-effects para_num="24" id="string.view.ops.24">
    
    <dt>Effects:</dt><dd>Equivalent to <code>substr(pos1, n1).compare(str)</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="25" id="string.view.ops.25">
    
    <pre><code><cxx-signature>constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
                      size_type pos2, size_type n2) const;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-effects para_num="26" id="string.view.ops.26">
    
    <dt>Effects:</dt><dd>Equivalent to <code>substr(pos1, n1).compare(str.substr(pos2, n2))</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="27" id="string.view.ops.27">
    
    <pre><code><cxx-signature>constexpr int compare(const charT* s) const;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-effects para_num="28" id="string.view.ops.28">
    
    <dt>Effects:</dt><dd>Equivalent to <code>compare(basic_string_view(s))</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="29" id="string.view.ops.29">
    
    <pre><code><cxx-signature>constexpr int compare(size_type pos1, size_type n1, const charT* s) const;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-effects para_num="30" id="string.view.ops.30">
    
    <dt>Effects:</dt><dd>Equivalent to <code>substr(pos1, n1).compare(basic_string_view(s))</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="31" id="string.view.ops.31">
    
    <pre><code><cxx-signature>constexpr int compare(size_type pos1, size_type n1,
                      const charT* s, size_type n2) const;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-effects para_num="32" id="string.view.ops.32">
    
    <dt>Effects:</dt><dd>Equivalent to <code>substr(pos1, n1).compare(basic_string_view(s, n2))</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>

    <cxx-section id="string.view.find">
    

    <section>
      <header><span class="section-number">7.8.1</span> <h1 data-bookmark-label="7.8.1 Searching basic_string_view">Searching <code>basic_string_view</code></h1> <span style="float:right"><a href="#string.view.find">[string.view.find]</a></span></header>
      
      

      <p para_num="1" id="string.view.find.1">This section specifies the <code>basic_string_view</code> member functions named
        <code>find</code>, <code>rfind</code>, <code>find_first_of</code>, <code>find_last_of</code>, <code>find_first_not_of</code>, and <code>find_last_not_of</code>.</p>

      <p para_num="2" id="string.view.find.2">Member functions in this section have complexity O(<code>size() * str.size()</code>) at worst,
        although implementations are encouraged to do better.</p>

      <p para_num="3" id="string.view.find.3">Each member function of the form</p>
      <pre><code>constexpr <var>return-type fx1</var>(const charT* s, size_type pos);</code></pre>
      <p class="cont">is equivalent to <code><var>fx1</var>(basic_string_view(s), pos)</code>.</p>

      <p para_num="4" id="string.view.find.4">Each member function of the form</p>
      <pre><code>constexpr <var>return-type fx1</var>(const charT* s, size_type pos, size_type n);</code></pre>
      <p class="cont">is equivalent to <code><var>fx1</var>(basic_string_view(s, n), pos)</code>.</p>

      <p para_num="5" id="string.view.find.5">Each member function of the form</p>
      <pre><code>constexpr <var>return-type fx2</var>(charT c, size_type pos);</code></pre>
      <p class="cont">is equivalent to <code><var>fx2</var>(basic_string_view(&amp;c, 1), pos)</code>.</p>

      <cxx-function para_num="6" id="string.view.find.6">
    
    <pre><code><cxx-signature>constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="7" id="string.view.find.7">
    
    <dt>Effects:</dt><dd>
          Determines the lowest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>pos &lt;= xpos</code></li>
            <li><code>xpos + str.size() &lt;= size()</code></li>
            <li><code>traits::eq(at(xpos+I), str.at(I))</code> for all elements <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="8" id="string.view.find.8">
    
    <dt>Returns:</dt><dd><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="9" id="string.view.find.9">
    
    <dt>Remarks:</dt><dd>Uses <code>traits::eq()</code>.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="10" id="string.view.find.10">
    
    <pre><code><cxx-signature>constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="11" id="string.view.find.11">
    
    <dt>Effects:</dt><dd>
          Determines the highest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>xpos &lt;= pos</code></li>
            <li><code>xpos + str.size() &lt;= size()</code></li>
            <li><code>traits::eq(at(xpos+I), str.at(I))</code> for all elements <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="12" id="string.view.find.12">
    
    <dt>Returns:</dt><dd><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="13" id="string.view.find.13">
    
    <dt>Remarks:</dt><dd>Uses <code>traits::eq()</code>.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="14" id="string.view.find.14">
    
    <pre><code><cxx-signature>constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="15" id="string.view.find.15">
    
    <dt>Effects:</dt><dd>Determines the lowest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>pos &lt;= xpos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for some element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="16" id="string.view.find.16">
    
    <dt>Returns:</dt><dd><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="17" id="string.view.find.17">
    
    <dt>Remarks:</dt><dd>Uses <code>traits::eq()</code>.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="18" id="string.view.find.18">
    
    <pre><code><cxx-signature>constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="19" id="string.view.find.19">
    
    <dt>Effects:</dt><dd>Determines the highest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>xpos &lt;= pos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for some element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="20" id="string.view.find.20">
    
    <dt>Returns:</dt><dd><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="21" id="string.view.find.21">
    
    <dt>Remarks:</dt><dd>Uses <code>traits::eq()</code>.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="22" id="string.view.find.22">
    
    <pre><code><cxx-signature>constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="23" id="string.view.find.23">
    
    <dt>Effects:</dt><dd>Determines the lowest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>pos &lt;= xpos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for no element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="24" id="string.view.find.24">
    
    <dt>Returns:</dt><dd><code>xpos</code> if the function can determine such a value for <code>xpos</code>. Otherwise, returns <code>npos</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="25" id="string.view.find.25">
    
    <dt>Remarks:</dt><dd>Uses <code>traits::eq()</code>.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="26" id="string.view.find.26">
    
    <pre><code><cxx-signature>constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="27" id="string.view.find.27">
    
    <dt>Effects:</dt><dd>Determines the highest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>xpos &lt;= pos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for no element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </dd>
  </cxx-effects>
        <cxx-returns para_num="28" id="string.view.find.28">
    
    <dt>Returns:</dt><dd><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="29" id="string.view.find.29">
    
    <dt>Remarks:</dt><dd>Uses <code>traits::eq()</code>.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.comparison">
    

    <section>
      <header><span class="section-number">7.9</span> <h1 data-bookmark-label="7.9 basic_string_view non-member comparison functions"><code>basic_string_view</code> non-member comparison functions</h1> <span style="float:right"><a href="#string.view.comparison">[string.view.comparison]</a></span></header>
      
    

    <p para_num="1" id="string.view.comparison.1">
      Let <code>S</code> be <code>basic_string_view&lt;charT, traits&gt;</code>, and <code>sv</code> be an instance of <code>S</code>.
      Implementations shall provide sufficient additional overloads marked <code>constexpr</code> and <code>noexcept</code>
      so that an object <code><var>t</var></code> with an implicit conversion to <code>S</code> can be compared according to <cxx-ref to="tab:string.view.comparison.overloads"><a title="tab:string.view.comparison.overloads" href="#tab:string.view.comparison.overloads">Table 11</a></cxx-ref>.
    </p>

    <table is="cxx-table" id="tab:string.view.comparison.overloads" class="center">
    

    <caption>Table 11 — <wbr><span>Additional <code>basic_string_view</code> comparison overloads</span></caption>
    
      <tbody><tr><th>Expression</th><th>Equivalent to</th></tr>
      <tr><td><code>t == sv</code></td><td><code>S(t) == sv</code></td></tr>
      <tr><td><code>sv == t</code></td><td><code>sv == S(t)</code></td></tr>
      <tr><td><code>t != sv</code></td><td><code>S(t) != sv</code></td></tr>
      <tr><td><code>sv != t</code></td><td><code>sv != S(t)</code></td></tr>
      <tr><td><code>t &lt; sv</code></td><td><code>S(t) &lt; sv</code></td></tr>
      <tr><td><code>sv &lt; t</code></td><td><code>sv &lt; S(t)</code></td></tr>
      <tr><td><code>t &gt; sv</code></td><td><code>S(t) &gt; sv</code></td></tr>
      <tr><td><code>sv &gt; t</code></td><td><code>sv &gt; S(t)</code></td></tr>
      <tr><td><code>t &lt;= sv</code></td><td><code>S(t) &lt;= sv</code></td></tr>
      <tr><td><code>sv &lt;= t</code></td><td><code>sv &lt;= S(t)</code></td></tr>
      <tr><td><code>t &gt;= sv</code></td><td><code>S(t) &gt;= sv</code></td></tr>
      <tr><td><code>sv &gt;= t</code></td><td><code>sv &gt;= S(t)</code></td></tr>
    </tbody>
  </table>

    <cxx-example>
    
    <span class="nowrap">[ <em>Example:</em></span>
    A sample conforming implementation for operator== would be:
<pre><code>template&lt;class T&gt; using __identity = decay_t&lt;T&gt;;
template&lt;class charT, class traits&gt;
constexpr bool operator==(
    basic_string_view&lt;charT, traits&gt; lhs,
    basic_string_view&lt;charT, traits&gt; rhs) noexcept {
  return lhs.compare(rhs) == 0;
}
template&lt;class charT, class traits&gt;
constexpr bool operator==(
    basic_string_view&lt;charT, traits&gt; lhs,
    __identity&lt;basic_string_view&lt;charT, traits&gt;&gt; rhs) noexcept {
  return lhs.compare(rhs) == 0;
}
template&lt;class charT, class traits&gt;
constexpr bool operator==(
    __identity&lt;basic_string_view&lt;charT, traits&gt;&gt; lhs,
    basic_string_view&lt;charT, traits&gt; rhs) noexcept {
  return lhs.compare(rhs) == 0;
}</code></pre>
    
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>

    <cxx-function para_num="2" id="string.view.comparison.2">
    
    <pre><code><cxx-signature>template&lt;class charT, class traits&gt;
  constexpr bool operator==(basic_string_view&lt;charT, traits&gt; lhs,
                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="3" id="string.view.comparison.3">
    
    <dt>Returns:</dt><dd> <code>lhs.compare(rhs) == 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="4" id="string.view.comparison.4">
    
    <pre><code><cxx-signature>template&lt;class charT, class traits&gt;
  constexpr bool operator!=(basic_string_view&lt;charT, traits&gt; lhs,
                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="5" id="string.view.comparison.5">
    
    <dt>Returns:</dt><dd> <code>lhs.compare(rhs) != 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="6" id="string.view.comparison.6">
    
    <pre><code><cxx-signature>template&lt;class charT, class traits&gt;
  constexpr bool operator&lt; (basic_string_view&lt;charT, traits&gt; lhs,
                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="7" id="string.view.comparison.7">
    
    <dt>Returns:</dt><dd> <code>lhs.compare(rhs) &lt; 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="8" id="string.view.comparison.8">
    
    <pre><code><cxx-signature>template&lt;class charT, class traits&gt;
  constexpr bool operator&gt; (basic_string_view&lt;charT, traits&gt; lhs,
                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="9" id="string.view.comparison.9">
    
    <dt>Returns:</dt><dd> <code>lhs.compare(rhs) &gt; 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="10" id="string.view.comparison.10">
    
    <pre><code><cxx-signature>template&lt;class charT, class traits&gt;
  constexpr bool operator&lt;=(basic_string_view&lt;charT, traits&gt; lhs,
                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="11" id="string.view.comparison.11">
    
    <dt>Returns:</dt><dd> <code>lhs.compare(rhs) &lt;= 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="12" id="string.view.comparison.12">
    
    <pre><code><cxx-signature>template&lt;class charT, class traits&gt;
  constexpr bool operator&gt;=(basic_string_view&lt;charT, traits&gt; lhs,
                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="13" id="string.view.comparison.13">
    
    <dt>Returns:</dt><dd> <code>lhs.compare(rhs) &gt;= 0</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.io">
    

    <section>
      <header><span class="section-number">7.10</span> <h1 data-bookmark-label="7.10 Inserters and extractors">Inserters and extractors</h1> <span style="float:right"><a href="#string.view.io">[string.view.io]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.io.1">
    
    <pre><code><cxx-signature>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);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="2" id="string.view.io.2">
    
    <dt>Effects:</dt><dd>Equivalent to <code>os &lt;&lt; str.to_string()</code>.</dd>
  </cxx-effects>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="string.view.hash">
    

    <section>
      <header><span class="section-number">7.11</span> <h1 data-bookmark-label="7.11 Hash support">Hash support</h1> <span style="float:right"><a href="#string.view.hash">[string.view.hash]</a></span></header>
      
    

    <cxx-function para_num="1" id="string.view.hash.1">
    
    <pre><code><cxx-signature>template &lt;&gt; struct hash&lt;experimental::string_view&gt;;</cxx-signature><cxx-signature>template &lt;&gt; struct hash&lt;experimental::u16string_view&gt;;</cxx-signature><cxx-signature>template &lt;&gt; struct hash&lt;experimental::u32string_view&gt;;</cxx-signature><cxx-signature>template &lt;&gt; struct hash&lt;experimental::wstring_view&gt;;</cxx-signature></code></pre>

    <dl>
      
      
      
      
      
      <p para_num="2" id="string.view.hash.2">The template specializations shall meet the requirements of class template hash (<cxx-ref in="cxx" to="unord.hash">C++14 <span title="unord.hash">§20.9.12</span></cxx-ref>).</p>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="memory">
    

    <section>
      <header><span class="section-number">8</span> <h1 data-bookmark-label="8 Memory">Memory</h1> <span style="float:right"><a href="#memory">[memory]</a></span></header>
      
  

  <cxx-section id="header.memory.synop">
    

    <section>
      <header><span class="section-number">8.1</span> <h1 data-bookmark-label="8.1 Header <experimental/memory> synopsis">Header &lt;experimental/memory&gt; synopsis</h1> <span style="float:right"><a href="#header.memory.synop">[header.memory.synop]</a></span></header>
      
    

<pre><code>#include &lt;memory&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  // See <cxx-ref in="cxx" to="allocator.uses">C++14 <span title="allocator.uses">§20.7.7</span></cxx-ref>, uses_allocator
  template &lt;class T, class Alloc&gt; constexpr bool uses_allocator_v
    = uses_allocator&lt;T, Alloc&gt;::value;

  <cxx-ref insynopsis="" to="memory.smartptr.shared">// <i><a title="memory.smartptr.shared" href="#memory.smartptr.shared">8.2.1</a>, Class template shared_ptr</i></cxx-ref>
  template&lt;class T&gt; class shared_ptr;

  // <cxx-ref in="cxx" to="util.smartptr.shared.create">C++14 <span title="util.smartptr.shared.create">§20.8.2.2.6</span></cxx-ref>
  template&lt;class T, class... Args&gt; shared_ptr&lt;T&gt; make_shared(Args&amp;&amp;... args);
  template&lt;class T, class A, class... Args&gt;
    shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);

  // <cxx-ref in="cxx" to="util.smartptr.shared.cmp">C++14 <span title="util.smartptr.shared.cmp">§20.8.2.2.7</span></cxx-ref>
  template&lt;class T, class U&gt;
    bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator==(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.shared.spec">C++14 <span title="util.smartptr.shared.spec">§20.8.2.2.8</span></cxx-ref>
  template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b) noexcept;

  <cxx-ref insynopsis="" to="memory.smartptr.shared.cast">// <i><a title="memory.smartptr.shared.cast" href="#memory.smartptr.shared.cast">8.2.1.3</a>, shared_ptr casts</i></cxx-ref>
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; static_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; dynamic_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; const_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; reinterpret_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.getdeleter">C++14 <span title="util.smartptr.getdeleter">§20.8.2.2.10</span></cxx-ref>
  template&lt;class D, class T&gt; D* get_deleter(const shared_ptr&lt;T&gt;&amp; p) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.shared.io">C++14 <span title="util.smartptr.shared.io">§20.8.2.2.11</span></cxx-ref>
  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, const shared_ptr&lt;Y&gt;&amp; p);

  // <cxx-ref in="cxx" to="util.smartptr.weak">C++14 <span title="util.smartptr.weak">§20.8.2.3</span></cxx-ref>
  template&lt;class T&gt; class weak_ptr;

  // <cxx-ref in="cxx" to="util.smartptr.weak.spec">C++14 <span title="util.smartptr.weak.spec">§20.8.2.3.6</span></cxx-ref>
  template&lt;class T&gt; void swap(weak_ptr&lt;T&gt;&amp; a, weak_ptr&lt;T&gt;&amp; b) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.ownerless">C++14 <span title="util.smartptr.ownerless">§20.8.2.4</span></cxx-ref>
  template&lt;class T&gt; class owner_less;

  // <cxx-ref in="cxx" to="util.smartptr.enab">C++14 <span title="util.smartptr.enab">§20.8.2.5</span></cxx-ref>
  template&lt;class T&gt; class enable_shared_from_this;

  // <cxx-ref in="cxx" to="util.smartptr.shared.atomic">C++14 <span title="util.smartptr.shared.atomic">§20.8.2.6</span></cxx-ref>
  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);

} // namespace fundamentals_v1
} // namespace experimental

  // <cxx-ref in="cxx" to="util.smartptr.hash">C++14 <span title="util.smartptr.hash">§20.8.2.7</span></cxx-ref>
  template&lt;class T&gt; struct hash&lt;experimental::shared_ptr&lt;T&gt;&gt;;

} // namespace std</code></pre>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.smartptr">
    

    <section>
      <header><span class="section-number">8.2</span> <h1 data-bookmark-label="8.2 Shared-ownership pointers">Shared-ownership pointers</h1> <span style="float:right"><a href="#memory.smartptr">[memory.smartptr]</a></span></header>
      
    

      <p para_num="1" id="memory.smartptr.1">
        The specification of all declarations within this sub-clause <cxx-ref to="memory.smartptr"><a title="memory.smartptr" href="#memory.smartptr">8.2</a></cxx-ref> and its sub-clauses are the same as the corresponding declarations, as specified in <cxx-ref in="cxx" to="util.smartptr">C++14 <span title="util.smartptr">§20.8.2</span></cxx-ref>, unless explicitly specified otherwise.
      </p>

  <cxx-section id="memory.smartptr.shared">
    

    <section>
      <header><span class="section-number">8.2.1</span> <h1 data-bookmark-label="8.2.1 Class template shared_ptr">Class template shared_ptr</h1> <span style="float:right"><a href="#memory.smartptr.shared">[memory.smartptr.shared]</a></span></header>
      
    

<pre><code>
namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  template&lt;class T&gt; class shared_ptr {
  public:
    typedef typename remove_extent_t&lt;T&gt; element_type;
    <cxx-ref insynopsis="" to="memory.smartptr.shared.const">// <i><a title="memory.smartptr.shared.const" href="#memory.smartptr.shared.const">8.2.1.1</a>, shared_ptr constructors</i></cxx-ref>
    constexpr shared_ptr() noexcept;
    template&lt;class Y&gt; explicit shared_ptr(Y* p);
    template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
    template&lt;class Y, class D, class A&gt; shared_ptr(Y* p, D d, A a);
    template &lt;class D&gt; shared_ptr(nullptr_t p, D d)
    template &lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
    template&lt;class Y&gt; shared_ptr(const shared_ptr&lt;Y&gt;&amp; r, element_type* p) noexcept;
    shared_ptr(const shared_ptr&amp; r) noexcept;
    template&lt;class Y&gt; shared_ptr(const shared_ptr&lt;Y&gt;&amp; r) noexcept;
    shared_ptr(shared_ptr&amp;&amp; r) noexcept;
    template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt;&amp;&amp; r) noexcept;
    template&lt;class Y&gt; explicit shared_ptr(const weak_ptr&lt;Y&gt;&amp; r);
    template&lt;class Y&gt; shared_ptr(auto_ptr&lt;Y&gt;&amp;&amp; r);
    template &lt;class Y, class D&gt; shared_ptr(unique_ptr&lt;Y, D&gt;&amp;&amp; r);
    constexpr shared_ptr(nullptr_t) : shared_ptr() { }

    // <cxx-ref in="cxx" to="util.smartptr.shared.dest">C++14 <span title="util.smartptr.shared.dest">§20.8.2.2.2</span></cxx-ref>
    ~shared_ptr();

    // <cxx-ref in="cxx" to="util.smartptr.shared.assign">C++14 <span title="util.smartptr.shared.assign">§20.8.2.2.3</span></cxx-ref>
    shared_ptr&amp; operator=(const shared_ptr&amp; r) noexcept;
    template&lt;class Y&gt; shared_ptr&amp; operator=(const shared_ptr&lt;Y&gt;&amp; r) noexcept;
    shared_ptr&amp; operator=(shared_ptr&amp;&amp; r) noexcept;
    template&lt;class Y&gt; shared_ptr&amp; operator=(shared_ptr&lt;Y&gt;&amp;&amp; r) noexcept;
    template&lt;class Y&gt; shared_ptr&amp; operator=(auto_ptr&lt;Y&gt;&amp;&amp; r);
    template &lt;class Y, class D&gt; shared_ptr&amp; operator=(unique_ptr&lt;Y, D&gt;&amp;&amp; r);

    // <cxx-ref in="cxx" to="util.smartptr.shared.mod">C++14 <span title="util.smartptr.shared.mod">§20.8.2.2.4</span></cxx-ref>
    void swap(shared_ptr&amp; r) noexcept;
    void reset() noexcept;
    template&lt;class Y&gt; void reset(Y* p);
    template&lt;class Y, class D&gt; void reset(Y* p, D d);
    template&lt;class Y, class D, class A&gt; void reset(Y* p, D d, A a);

    <cxx-ref insynopsis="" to="memory.smartptr.shared.obs">// <i><a title="memory.smartptr.shared.obs" href="#memory.smartptr.shared.obs">8.2.1.2</a>, shared_ptr observers</i></cxx-ref>
    element_type* get() const noexcept;
    T&amp; operator*() const noexcept;
    T* operator-&gt;() const noexcept;
    element_type&amp; operator[](ptrdiff_t i) const noexcept;
    long use_count() const noexcept;
    bool unique() const noexcept;
    explicit operator bool() const noexcept;
    template&lt;class U&gt; bool owner_before(shared_ptr&lt;U&gt; const&amp; b) const;
    template&lt;class U&gt; bool owner_before(weak_ptr&lt;U&gt; const&amp; b) const;
  };

  // <cxx-ref in="cxx" to="util.smartptr.shared.create">C++14 <span title="util.smartptr.shared.create">§20.8.2.2.6</span></cxx-ref>
  template&lt;class T, class... Args&gt; shared_ptr&lt;T&gt; make_shared(Args&amp;&amp;... args);
  template&lt;class T, class A, class... Args&gt;
    shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);

  // <cxx-ref in="cxx" to="util.smartptr.shared.cmp">C++14 <span title="util.smartptr.shared.cmp">§20.8.2.2.7</span></cxx-ref>
  template&lt;class T, class U&gt;
    bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator==(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;
  template &lt;class T&gt;
    bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;
  template &lt;class T&gt;
    bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; b) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.shared.spec">C++14 <span title="util.smartptr.shared.spec">§20.8.2.2.8</span></cxx-ref>
  template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b) noexcept;

  <cxx-ref insynopsis="" to="memory.smartptr.shared.cast">// <i><a title="memory.smartptr.shared.cast" href="#memory.smartptr.shared.cast">8.2.1.3</a>, shared_ptr casts</i></cxx-ref>
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; static_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; dynamic_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; const_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;
  template&lt;class T, class U&gt;
    shared_ptr&lt;T&gt; reinterpret_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.getdeleter">C++14 <span title="util.smartptr.getdeleter">§20.8.2.2.10</span></cxx-ref>
  template&lt;class D, class T&gt; D* get_deleter(const shared_ptr&lt;T&gt;&amp; p) noexcept;

  // <cxx-ref in="cxx" to="util.smartptr.shared.io">C++14 <span title="util.smartptr.shared.io">§20.8.2.2.11</span></cxx-ref>
  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, const shared_ptr&lt;Y&gt;&amp; p);

  // <cxx-ref in="cxx" to="util.smartptr.ownerless">C++14 <span title="util.smartptr.ownerless">§20.8.2.4</span></cxx-ref>
  template&lt;class T&gt; class owner_less;

  // <cxx-ref in="cxx" to="util.smartptr.enab">C++14 <span title="util.smartptr.enab">§20.8.2.5</span></cxx-ref>
  template&lt;class T&gt; class enable_shared_from_this;

  // <cxx-ref in="cxx" to="util.smartptr.shared.atomic">C++14 <span title="util.smartptr.shared.atomic">§20.8.2.6</span></cxx-ref>
  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);


} // namespace fundamentals_v1
} // namespace experimental

  // <cxx-ref in="cxx" to="util.smartptr.hash">C++14 <span title="util.smartptr.hash">§20.8.2.7</span></cxx-ref>
  template&lt;class T&gt; struct hash&lt;experimental::shared_ptr&lt;T&gt;&gt;;

} // namespace std</code></pre>

      <p para_num="1" id="memory.smartptr.shared.1">
        For the purposes of subclause <cxx-ref to="memory.smartptr"><a title="memory.smartptr" href="#memory.smartptr">8.2</a></cxx-ref>, a pointer type <code>Y*</code> is said to be <dfn>compatible with</dfn> a pointer type <code>T*</code> when either <code>Y*</code> is convertible to <code>T*</code> or <code>Y</code> is <code>U[N]</code> and <code>T</code> is <code>U <var>cv</var> []</code>.
      </p>

  <cxx-section id="memory.smartptr.shared.const">
    

    <section>
      <header><span class="section-number">8.2.1.1</span> <h1 data-bookmark-label="8.2.1.1 shared_ptr constructors"><code>shared_ptr</code> constructors</h1> <span style="float:right"><a href="#memory.smartptr.shared.const">[memory.smartptr.shared.const]</a></span></header>
      
    

      <cxx-function para_num="1" id="memory.smartptr.shared.const.1">
    
    <pre><code><cxx-signature>template&lt;class Y&gt; explicit shared_ptr(Y* p);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="memory.smartptr.shared.const.2">
    
    <dt>Requires:</dt><dd><code>Y</code> shall be a complete type.
        The expression <code>delete[] p</code>, when <code>T</code> is an array type,
        or <code>delete p</code>, when <code>T</code> is not an array type,
        shall be well-formed, shall have well defined behavior, and shall not throw exceptions.
        When <code>T</code> is <code>U[N]</code>, <code>Y(*)[N]</code> shall be convertible to <code>T*</code>;
        when <code>T</code> is <code>U[]</code>, <code>Y(*)[]</code> shall be convertible to <code>T*</code>;
        otherwise, <code>Y*</code> shall be convertible to <code>T*</code>.</dd>
  </cxx-requires>

        <cxx-effects para_num="3" id="memory.smartptr.shared.const.3">
    
    <dt>Effects:</dt><dd>When <code>T</code> is not an array type, constructs a <code>shared_ptr</code> object that <i>owns</i> the pointer <code>p</code>.
        Otherwise, constructs a <code>shared_ptr</code> that <em>owns</em> <code>p</code> and a deleter of an unspecified type that calls <code>delete[] p</code>.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="4" id="memory.smartptr.shared.const.4">
    
    <dt>Postconditions:</dt><dd><code>use_count() == 1 &amp;&amp; get() == p</code>.</dd>
  </cxx-postconditions>

        <cxx-throws para_num="5" id="memory.smartptr.shared.const.5">
    
    <dt>Throws:</dt><dd><code>bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</dd>
  </cxx-throws>

        <cxx-exception-safety para_num="6" id="memory.smartptr.shared.const.6">
    
    <dt>Exception safety:</dt><dd>If an exception is thrown, <code>delete p</code> is called when <code>T</code> is not an array type, <code>delete[] p</code> otherwise.</dd>
  </cxx-exception-safety>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="7" id="memory.smartptr.shared.const.7">
    
    <pre><code><cxx-signature>template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);</cxx-signature><cxx-signature>template&lt;class Y, class D, class A&gt; shared_ptr(Y* p, D d, A a);</cxx-signature><cxx-signature>template &lt;class D&gt; shared_ptr(nullptr_t p, D d);</cxx-signature><cxx-signature>template &lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);</cxx-signature></code></pre>

    <dl>
      
        
        
        
        

        <cxx-requires para_num="8" id="memory.smartptr.shared.const.8">
    
    <dt>Requires:</dt><dd><code>D</code> shall be <code>CopyConstructible</code>. The copy constructor and destructor of <code> D</code> shall not throw exceptions. The expression <code>d(p)</code> shall be well formed, shall have well defined behavior, and shall not throw exceptions. <code>A</code> shall be an allocator (<cxx-ref in="cxx" to="allocator.requirements">C++14 <span title="allocator.requirements">§17.6.3.5</span></cxx-ref>). The copy constructor and destructor of <code>A</code> shall not throw exceptions.
        When <code>T</code> is <code>U[N]</code>, <code>Y(*)[N]</code> shall be convertible to <code>T*</code>;
        when <code>T</code> is <code>U[]</code>, <code>Y(*)[]</code> shall be convertible to <code>T*</code>;
        otherwise, <code>Y*</code> shall be convertible to <code>T*</code>.</dd>
  </cxx-requires>

        <cxx-effects para_num="9" id="memory.smartptr.shared.const.9">
    
    <dt>Effects:</dt><dd>Constructs a <code>shared_ptr</code> object that <i>owns</i> the object <code>p</code> and the deleter <code>d</code>. The second and fourth constructors shall use a copy of <code>a</code> to allocate memory for internal use.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="10" id="memory.smartptr.shared.const.10">
    
    <dt>Postconditions:</dt><dd><code>use_count() == 1 &amp;&amp; get() == p</code>.</dd>
  </cxx-postconditions>

        <cxx-throws para_num="11" id="memory.smartptr.shared.const.11">
    
    <dt>Throws:</dt><dd><code>bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</dd>
  </cxx-throws>

        <cxx-exception-safety para_num="12" id="memory.smartptr.shared.const.12">
    
    <dt>Exception safety:</dt><dd>If an exception is thrown, <code>d(p)</code> is called.</dd>
  </cxx-exception-safety>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="13" id="memory.smartptr.shared.const.13">
    
    <pre><code><cxx-signature>template&lt;class Y&gt; shared_ptr(const shared_ptr&lt;Y&gt;&amp; r, element_type* p) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="14" id="memory.smartptr.shared.const.14">
    
    <dt>Effects:</dt><dd>Constructs a <code>shared_ptr</code> instance that stores <code>p</code> and <i>shares ownership</i> with <code>r</code>.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="15" id="memory.smartptr.shared.const.15">
    
    <dt>Postconditions:</dt><dd><code>get() == p &amp;&amp; use_count() == r.use_count()</code></dd>
  </cxx-postconditions>

        <p para_num="16" id="memory.smartptr.shared.const.16">
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    To avoid the possibility of a dangling pointer, the user of this constructor must ensure that <code>p</code> remains valid at least until the ownership group of <code>r</code> is destroyed.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
        </p>

        <p para_num="17" id="memory.smartptr.shared.const.17">
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    This constructor allows creation of an <i>empty</i> <code>shared_ptr</code> instance with a non-null stored pointer.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
        </p>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="18" id="memory.smartptr.shared.const.18">
    
    <pre><code><cxx-signature>shared_ptr(const shared_ptr&amp; r) noexcept;</cxx-signature><cxx-signature>template&lt;class Y&gt; shared_ptr(const shared_ptr&lt;Y&gt;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-requires para_num="19" id="memory.smartptr.shared.const.19">
    
    <dt>Requires:</dt><dd> The second constructor shall not participate in the overload resolution unless <code>Y*</code> is <i>compatible with</i> <code>T*</code>.</dd>
  </cxx-requires>

        <cxx-effects para_num="20" id="memory.smartptr.shared.const.20">
    
    <dt>Effects:</dt><dd>If <code>r</code> is <i>empty</i>, constructs an <i>empty</i> <code>shared_ptr</code> object; otherwise, constructs a <code>shared_ptr</code> object that <i>shares ownership</i> with <code>r</code>.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="21" id="memory.smartptr.shared.const.21">
    
    <dt>Postconditions:</dt><dd><code>get() == r.get() &amp;&amp; use_count() == r.use_count()</code>.</dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="22" id="memory.smartptr.shared.const.22">
    
    <pre><code><cxx-signature>shared_ptr(shared_ptr&amp;&amp; r) noexcept;</cxx-signature><cxx-signature>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt;&amp;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> N3920 specifies that "implicitly convertible" is removed, but the C++14 draft only has "convertible". Does this make a difference?</aside>
  </cxx-ednote>
        <cxx-remarks para_num="23" id="memory.smartptr.shared.const.23">
    
    <dt>Remarks:</dt><dd>The second constructor shall not participate in overload resolution unless <code>Y*</code> is <i>compatible with</i> <code>T*</code>.</dd>
  </cxx-remarks>

        <cxx-effects para_num="24" id="memory.smartptr.shared.const.24">
    
    <dt>Effects:</dt><dd>Move-constructs a <code>shared_ptr</code> instance from <code>r</code>.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="25" id="memory.smartptr.shared.const.25">
    
    <dt>Postconditions:</dt><dd><code>*this</code> shall contain the old value of <code>r</code>. <code>r</code> shall be <i>empty</i>. <code>r.get() == 0.</code></dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="26" id="memory.smartptr.shared.const.26">
    
    <pre><code><cxx-signature>template&lt;class Y&gt; explicit shared_ptr(const weak_ptr&lt;Y&gt;&amp; r);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="27" id="memory.smartptr.shared.const.27">
    
    <dt>Requires:</dt><dd><code>Y*</code> shall be <i>compatible with</i> <code>T*</code>.</dd>
  </cxx-requires>

        <cxx-effects para_num="28" id="memory.smartptr.shared.const.28">
    
    <dt>Effects:</dt><dd>Constructs a <code>shared_ptr</code> object that <i>shares ownership</i> with <code>r</code> and stores a copy of the pointer stored in <code>r</code>.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="29" id="memory.smartptr.shared.const.29">
    
    <dt>Postconditions:</dt><dd><code>use_count() == r.use_count()</code>.</dd>
  </cxx-postconditions>

        <cxx-throws para_num="30" id="memory.smartptr.shared.const.30">
    
    <dt>Throws:</dt><dd><code>bad_weak_ptr</code> when <code>r.expired()</code>.</dd>
  </cxx-throws>

        <cxx-exception-safety para_num="31" id="memory.smartptr.shared.const.31">
    
    <dt>Exception safety:</dt><dd>If an exception is thrown, the constructor has no effect.</dd>
  </cxx-exception-safety>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="32" id="memory.smartptr.shared.const.32">
    
    <pre><code><cxx-signature>template &lt;class Y, class D&gt; shared_ptr(unique_ptr&lt;Y, D&gt;&amp;&amp; r);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="33" id="memory.smartptr.shared.const.33">
    
    <dt>Requires:</dt><dd><code>Y*</code> shall be <em>compatible with</em> <code>T*</code>.</dd>
  </cxx-requires>

        <cxx-effects para_num="34" id="memory.smartptr.shared.const.34">
    
    <dt>Effects:</dt><dd>Equivalent to <code>shared_ptr(r.release(), r.get_deleter())</code> when <code>D</code> is not a reference type, otherwise <code>shared_ptr(r.release(), ref(r.get_deleter()))</code>.</dd>
  </cxx-effects>

        <cxx-exception-safety para_num="35" id="memory.smartptr.shared.const.35">
    
    <dt>Exception safety:</dt><dd>If an exception is thrown, the constructor has no effect.</dd>
  </cxx-exception-safety>
      
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.smartptr.shared.obs">
    

    <section>
      <header><span class="section-number">8.2.1.2</span> <h1 data-bookmark-label="8.2.1.2 shared_ptr observers"><code>shared_ptr</code> observers</h1> <span style="float:right"><a href="#memory.smartptr.shared.obs">[memory.smartptr.shared.obs]</a></span></header>
      
    

      <cxx-function para_num="1" id="memory.smartptr.shared.obs.1">
    
    <pre><code><cxx-signature>element_type* get() const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="2" id="memory.smartptr.shared.obs.2">
    
    <dt>Returns:</dt><dd>The stored pointer.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.smartptr.shared.obs.3">
    
    <pre><code><cxx-signature>T&amp; operator*() const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="4" id="memory.smartptr.shared.obs.4">
    
    <dt>Requires:</dt><dd><code>get() != 0</code>.</dd>
  </cxx-requires>

        <cxx-returns para_num="5" id="memory.smartptr.shared.obs.5">
    
    <dt>Returns:</dt><dd><code>*get()</code>.</dd>
  </cxx-returns>

        <cxx-remarks para_num="6" id="memory.smartptr.shared.obs.6">
    
    <dt>Remarks:</dt><dd>When <code>T</code> is an array type or cv-qualified <code>void</code>, it is unspecified whether this member function is declared. If it is declared, it is unspecified what its return type is, except that the declaration (although not necessarily the definition) of the function shall be well formed.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="7" id="memory.smartptr.shared.obs.7">
    
    <pre><code><cxx-signature>T* operator-&gt;() const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="8" id="memory.smartptr.shared.obs.8">
    
    <dt>Requires:</dt><dd><code>get() != 0</code>.</dd>
  </cxx-requires>

        <cxx-returns para_num="9" id="memory.smartptr.shared.obs.9">
    
    <dt>Returns:</dt><dd><code>get()</code>.</dd>
  </cxx-returns>
        <cxx-remarks para_num="10" id="memory.smartptr.shared.obs.10">
    
    <dt>Remarks:</dt><dd>When <code>T</code> is an array type, it is unspecified whether this member function is declared.
        If it is declared, it is unspecified what its return type is, except that the declaration (although not necessarily the definition) of the function shall be well formed.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

        <cxx-function para_num="11" id="memory.smartptr.shared.obs.11">
    
    <pre><code><cxx-signature>element_type&amp; operator[](ptrdiff_t i) const noexcept;</cxx-signature></code></pre>

    <dl>
      
          

          <cxx-requires para_num="12" id="memory.smartptr.shared.obs.12">
    
    <dt>Requires:</dt><dd><code>get() != 0 &amp;&amp; i &gt;= 0</code>. If <code>T</code> is <code>U[N]</code>, <code>i &lt; N</code>.</dd>
  </cxx-requires>
          <cxx-returns para_num="13" id="memory.smartptr.shared.obs.13">
    
    <dt>Returns:</dt><dd><code>get()[i]</code>.</dd>
  </cxx-returns>
          <cxx-remarks para_num="14" id="memory.smartptr.shared.obs.14">
    
    <dt>Remarks:</dt><dd>When <code>T</code> is not an array type, it is unspecified whether this member function is declared.
          If it is declared, it is unspecified what its return type is, except that the declaration (although not necessarily the definition) of the function shall be well formed.</dd>
  </cxx-remarks>
        
    </dl>
  </cxx-function>

  
    </section>
  </cxx-section>

  <cxx-section id="memory.smartptr.shared.cast">
    

    <section>
      <header><span class="section-number">8.2.1.3</span> <h1 data-bookmark-label="8.2.1.3 shared_ptr casts"><code>shared_ptr</code> casts</h1> <span style="float:right"><a href="#memory.smartptr.shared.cast">[memory.smartptr.shared.cast]</a></span></header>
      
    

      <cxx-function para_num="1" id="memory.smartptr.shared.cast.1">
    
    <pre><code><cxx-signature>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; static_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="memory.smartptr.shared.cast.2">
    
    <dt>Requires:</dt><dd>The expression <code>static_cast&lt;T*&gt;((U*)0)</code> shall be well formed.</dd>
  </cxx-requires>

        <cxx-returns para_num="3" id="memory.smartptr.shared.cast.3">
    
    <dt>Returns:</dt><dd><code>shared_ptr&lt;T&gt;(r, static_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()))</code></dd>
  </cxx-returns>

        <p para_num="4" id="memory.smartptr.shared.cast.4">
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The seemingly equivalent expression <code>shared_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code> will eventually result in undefined behavior, attempting to delete the same object twice.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
        </p>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="memory.smartptr.shared.cast.5">
    
    <pre><code><cxx-signature>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; dynamic_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="6" id="memory.smartptr.shared.cast.6">
    
    <dt>Requires:</dt><dd>The expression <code>dynamic_cast&lt;T*&gt;((U*)0)</code> shall be well formed.</dd>
  </cxx-requires>

        <cxx-returns para_num="7" id="memory.smartptr.shared.cast.7">
    
    <dt>Returns:</dt><dd>
          <ul>
            <li>When <code>dynamic_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get())</code> returns a nonzero value <code>p</code>, <code>shared_ptr&lt;T&gt;(r, p)</code>;</li>

            <li>Otherwise, <code>shared_ptr&lt;T&gt;()</code>.</li>
          </ul>
        </dd>
  </cxx-returns>

        <p para_num="8" id="memory.smartptr.shared.cast.8">
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The seemingly equivalent expression <code>shared_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</code> will eventually result in undefined behavior, attempting to delete the same object twice.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
        </p>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="9" id="memory.smartptr.shared.cast.9">
    
    <pre><code><cxx-signature>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; const_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="10" id="memory.smartptr.shared.cast.10">
    
    <dt>Requires:</dt><dd>The expression <code>const_cast&lt;T*&gt;((U*)0)</code> shall be well formed.</dd>
  </cxx-requires>

        <cxx-returns para_num="11" id="memory.smartptr.shared.cast.11">
    
    <dt>Returns:</dt><dd><code>shared_ptr&lt;T&gt;(r, const_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()))</code>.</dd>
  </cxx-returns>

        <p para_num="12" id="memory.smartptr.shared.cast.12">
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The seemingly equivalent expression <code>shared_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code> will eventually result in undefined behavior, attempting to delete the same object twice.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
        </p>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="13" id="memory.smartptr.shared.cast.13">
    
    <pre><code><cxx-signature>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; reinterpret_pointer_cast(const shared_ptr&lt;U&gt;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="14" id="memory.smartptr.shared.cast.14">
    
    <dt>Requires:</dt><dd>The expression <code>reinterpret_cast&lt;T*&gt;((U*)0)</code> shall be well formed.</dd>
  </cxx-requires>
        <cxx-returns para_num="15" id="memory.smartptr.shared.cast.15">
    
    <dt>Returns:</dt><dd><code>shared_ptr&lt;T&gt;(r, reinterpret_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()))</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.smartptr.weak">
    

    <section>
      <header><span class="section-number">8.2.2</span> <h1 data-bookmark-label="8.2.2 Class template weak_ptr">Class template weak_ptr</h1> <span style="float:right"><a href="#memory.smartptr.weak">[memory.smartptr.weak]</a></span></header>
      
    

<pre><code>
namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  template&lt;class T&gt; class weak_ptr {
  public:
    typedef typename remove_extent_t&lt;T&gt; element_type;

    <cxx-ref insynopsis="" to="memory.smartptr.weak.const">// <i><a title="memory.smartptr.weak.const" href="#memory.smartptr.weak.const">8.2.2.1</a>, weak_ptr constructors</i></cxx-ref>
    constexpr weak_ptr() noexcept;
    template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const&amp; r) noexcept;
    weak_ptr(weak_ptr const&amp; r) noexcept;
    template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const&amp; r) noexcept;
    weak_ptr(weak_ptr&amp;&amp; r) noexcept;
    template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt;&amp;&amp; r) noexcept;

    // <cxx-ref in="cxx" to="util.smartptr.weak.dest">C++14 <span title="util.smartptr.weak.dest">§20.8.2.3.2</span></cxx-ref>
    ~weak_ptr();

    // <cxx-ref in="cxx" to="util.smartptr.weak.assign">C++14 <span title="util.smartptr.weak.assign">§20.8.2.3.3</span></cxx-ref>
    weak_ptr&amp; operator=(weak_ptr const&amp; r) noexcept;
    template&lt;class Y&gt; weak_ptr&amp; operator=(weak_ptr&lt;Y&gt; const&amp; r) noexcept;
    template&lt;class Y&gt; weak_ptr&amp; operator=(shared_ptr&lt;Y&gt; const&amp; r) noexcept;
    weak_ptr&amp; operator=(weak_ptr&amp;&amp; r) noexcept;
    template&lt;class Y&gt; weak_ptr&amp; operator=(weak_ptr&lt;Y&gt;&amp;&amp; r) noexcept;

    // <cxx-ref in="cxx" to="util.smartptr.weak.mod">C++14 <span title="util.smartptr.weak.mod">§20.8.2.3.4</span></cxx-ref>
    void swap(weak_ptr&amp; r) noexcept;
    void reset() noexcept;

    // <cxx-ref in="cxx" to="util.smartptr.weak.obs">C++14 <span title="util.smartptr.weak.obs">§20.8.2.3.5</span></cxx-ref>
    long use_count() const noexcept;
    bool expired() const noexcept;
    shared_ptr&lt;T&gt; lock() const noexcept;
    template&lt;class U&gt; bool owner_before(shared_ptr&lt;U&gt; const&amp; b) const;
    template&lt;class U&gt; bool owner_before(weak_ptr&lt;U&gt; const&amp; b) const;
  };

  // <cxx-ref in="cxx" to="util.smartptr.weak.spec">C++14 <span title="util.smartptr.weak.spec">§20.8.2.3.6</span></cxx-ref>
  template&lt;class T&gt; void swap(weak_ptr&lt;T&gt;&amp; a, weak_ptr&lt;T&gt;&amp; b) noexcept;

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>

  <cxx-section id="memory.smartptr.weak.const">
    

    <section>
      <header><span class="section-number">8.2.2.1</span> <h1 data-bookmark-label="8.2.2.1 weak_ptr constructors"><code>weak_ptr</code> constructors</h1> <span style="float:right"><a href="#memory.smartptr.weak.const">[memory.smartptr.weak.const]</a></span></header>
      
    

      <cxx-function para_num="1" id="memory.smartptr.weak.const.1">
    
    <pre><code><cxx-signature>weak_ptr(const weak_ptr&amp; r) noexcept;</cxx-signature><cxx-signature>template&lt;class Y&gt; weak_ptr(const weak_ptr&lt;Y&gt;&amp; r) noexcept;</cxx-signature><cxx-signature>template&lt;class Y&gt; weak_ptr(const shared_ptr&lt;Y&gt;&amp; r) noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        
        

        <cxx-requires para_num="2" id="memory.smartptr.weak.const.2">
    
    <dt>Requires:</dt><dd>The second and third constructors shall not participate in the overload resolution unless <code>Y*</code> is <i>compatible with</i> <code>T*</code>.</dd>
  </cxx-requires>

        <cxx-effects para_num="3" id="memory.smartptr.weak.const.3">
    
    <dt>Effects:</dt><dd>If <code>r</code> is <i>empty</i>, constructs an <i>empty</i> <code>weak_ptr</code> object; otherwise, constructs a <code>weak_ptr</code> object that <i>shares ownership</i> with <code>r</code> and stores a copy of the pointer stored in <code>r</code>.</dd>
  </cxx-effects>

        <cxx-postconditions para_num="4" id="memory.smartptr.weak.const.4">
    
    <dt>Postconditions:</dt><dd><code>use_count() == r.use_count()</code>.</dd>
  </cxx-postconditions>
      
    </dl>
  </cxx-function>

    
    </section>
  </cxx-section>

    
    </section>
  </cxx-section>

  
    </section>
  </cxx-section>

  <cxx-section id="memory.type.erased.allocator">
    

    <section>
      <header><span class="section-number">8.3</span> <h1 data-bookmark-label="8.3 Type-erased allocator">Type-erased allocator</h1> <span style="float:right"><a href="#memory.type.erased.allocator">[memory.type.erased.allocator]</a></span></header>
      
    

    <p para_num="1" id="memory.type.erased.allocator.1">
      A <dfn>type-erased allocator</dfn> is an allocator or memory resource, <code>alloc</code>,
      used to allocate internal data structures for an object <code>X</code> of type <code>C</code>,
      but where <code>C</code> is not dependent on the type of <code>alloc</code>.
      Once <code>alloc</code> has been supplied to <code>X</code> (typically as a constructor argument),
      <code>alloc</code> can be retrieved from <code>X</code> only as a pointer <code>rptr</code> of static type <code>std::experimental::pmr::memory_resource*</code> (<cxx-ref to="memory.resource"><a title="memory.resource" href="#memory.resource">8.5</a></cxx-ref>).
      The process by which <code>rptr</code> is computed from <code>alloc</code> depends on the type of <code>alloc</code> as described in <cxx-ref to="tab:memory.resource.type.erased.allocator"><a title="tab:memory.resource.type.erased.allocator" href="#tab:memory.resource.type.erased.allocator">Table 12</a></cxx-ref>:
    </p>

    <table is="cxx-table" id="tab:memory.resource.type.erased.allocator">
    

    <caption>Table 12 — <wbr><span>Computed <code>memory_resource</code> for type-erased allocator</span></caption>
    
      
      <thead>
        <tr>
          <th>If the type of <code>alloc</code> is</th>
          <th>then the value of <code>rptr</code> is</th>
        </tr>
      </thead>
      <tbody><tr>
        <td>non-existent — no <code>alloc</code> specified</td>
        <td>The value of <code>experimental::pmr::get_default_resource()</code> at the time of construction.</td>
      </tr>
      <tr>
        <td><code>nullptr_t</code></td>
        <td>The value of <code>experimental::pmr::get_default_resource()</code> at the time of construction.</td>
      </tr>
      <tr>
        <td>a pointer type convertible to <code>pmr::memory_resource*</code></td>
        <td><code>static_cast&lt;experimental::pmr::memory_resource*&gt;(alloc)</code></td>
      </tr>
      <tr>
        <td><code>pmr::polymorphic_allocator&lt;U&gt;</code></td>
        <td><code>alloc.resource()</code></td>
      </tr>
      <tr>
        <td>any other type meeting the Allocator requirements (<cxx-ref in="cxx" to="allocator.requirements">C++14 <span title="allocator.requirements">§17.6.3.5</span></cxx-ref>)</td>
        <td>a pointer to a value of type <code>experimental::pmr::resource_adaptor&lt;A&gt;</code> where <code>A</code> is the type of <code>alloc</code>.
        <code>rptr</code> remains valid only for the lifetime of <code>X</code>.</td>
      </tr>
      <tr>
        <td>None of the above</td>
        <td>The program is ill-formed.</td>
      </tr>
    </tbody>
  </table>

    <p para_num="2" id="memory.type.erased.allocator.2">Additionally, class <code>C</code> shall meet the following requirements:</p>
    <ul>
      <li><code>C::allocator_type</code> shall be identical to <code>std::experimental::erased_type</code>.</li>
      <li><code>X.get_memory_resource()</code> returns <code>rptr</code>.</li>
    </ul>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource.synop">
    

    <section>
      <header><span class="section-number">8.4</span> <h1 data-bookmark-label="8.4 Header <experimental/memory_resource> synopsis">Header <code>&lt;experimental/memory_resource&gt;</code> synopsis</h1> <span style="float:right"><a href="#memory.resource.synop">[memory.resource.synop]</a></span></header>
      
    

    <pre><code>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 <var>resource_adaptor_imp</var> is for exposition only.
  template &lt;class Allocator&gt; class <var>resource_adaptor_imp</var>;

  template &lt;class Allocator&gt;
    using resource_adaptor = <var>resource_adaptor_imp</var>&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</code></pre>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource">
    

    <section>
      <header><span class="section-number">8.5</span> <h1 data-bookmark-label="8.5 Class memory_resource">Class <code>memory_resource</code></h1> <span style="float:right"><a href="#memory.resource">[memory.resource]</a></span></header>
      
    

    <cxx-section id="memory.resource.overview">
    

    <section>
      <header><span class="section-number">8.5.1</span> <h1 data-bookmark-label="8.5.1 Class memory_resource overview">Class <code>memory_resource</code> overview</h1> <span style="float:right"><a href="#memory.resource.overview">[memory.resource.overview]</a></span></header>
      
      
      <p para_num="1" id="memory.resource.overview.1">
        The <code>memory_resource</code> class is an abstract interface to an unbounded set of classes encapsulating memory resources.
      </p>

      <pre><code>class memory_resource {
  // For exposition only
  static constexpr size_t max_align = alignof(max_align_t);

public:
  virtual ~memory_resource();

  void* allocate(size_t bytes, size_t alignment = max_align);
  void deallocate(void* p, size_t bytes,
                  size_t alignment = max_align);

  bool is_equal(const memory_resource&amp; other) const noexcept;

protected:
  virtual void* do_allocate(size_t bytes, size_t alignment) = 0;
  virtual void do_deallocate(void* p, size_t bytes,
                             size_t alignment) = 0;

  virtual bool do_is_equal(const memory_resource&amp; other) const noexcept = 0;
};</code></pre>

    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.public">
    

    <section>
      <header><span class="section-number">8.5.2</span> <h1 data-bookmark-label="8.5.2 memory_resource public member functions"><code>memory_resource</code> public member functions</h1> <span style="float:right"><a href="#memory.resource.public">[memory.resource.public]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.public.1">
    
    <pre><code><cxx-signature>~memory_resource();</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="memory.resource.public.2">
    
    <dt>Effects:</dt><dd>Destroys this memory_resource.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.resource.public.3">
    
    <pre><code><cxx-signature>void* allocate(size_t bytes, size_t alignment = max_align);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="4" id="memory.resource.public.4">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return do_allocate(bytes, alignment);</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="memory.resource.public.5">
    
    <pre><code><cxx-signature>void deallocate(void* p, size_t bytes, size_t alignment = max_align);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="6" id="memory.resource.public.6">
    
    <dt>Effects:</dt><dd>Equivalent to <code>do_deallocate(p, bytes, alignment);</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="7" id="memory.resource.public.7">
    
    <pre><code><cxx-signature>bool is_equal(const memory_resource&amp; other) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="8" id="memory.resource.public.8">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return do_is_equal(other);</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.priv">
    

    <section>
      <header><span class="section-number">8.5.3</span> <h1 data-bookmark-label="8.5.3 memory_resource protected virtual member functions"><code>memory_resource</code> protected virtual member functions</h1> <span style="float:right"><a href="#memory.resource.priv">[memory.resource.priv]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.priv.1">
    
    <pre><code><cxx-signature>virtual void* do_allocate(size_t bytes, size_t alignment) = 0;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="2" id="memory.resource.priv.2">
    
    <dt>Requires:</dt><dd>Alignment shall be a power of two.</dd>
  </cxx-requires>
        <cxx-returns para_num="3" id="memory.resource.priv.3">
    
    <dt>Returns:</dt><dd>A derived class shall implement this function to return a pointer to allocated storage (<cxx-ref in="cxx" to="basic.stc.dynamic.deallocation">C++14 <span title="basic.stc.dynamic.deallocation">§3.7.4.2</span></cxx-ref>) with a size of at least <code>bytes</code>.
        The returned storage is aligned to the specified alignment, if such alignment is supported;
        otherwise it is aligned to <code>max_align</code>.</dd>
  </cxx-returns>
        <cxx-throws para_num="4" id="memory.resource.priv.4">
    
    <dt>Throws:</dt><dd>A derived class implementation shall throw an appropriate exception if it is unable to allocate memory with the requested size and alignment.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="memory.resource.priv.5">
    
    <pre><code><cxx-signature>virtual void do_deallocate(void* p, size_t bytes, size_t alignment) = 0;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-requires para_num="6" id="memory.resource.priv.6">
    
    <dt>Requires:</dt><dd><code>p</code> shall have been returned from a prior call to <code>allocate(bytes, alignment)</code> on a memory resource equal to <code>*this</code>,
        and the storage at <code>p</code> shall not yet have been deallocated.</dd>
  </cxx-requires>
        <cxx-effects para_num="7" id="memory.resource.priv.7">
    
    <dt>Effects:</dt><dd>A derived class shall implement this function to dispose of allocated storage.</dd>
  </cxx-effects>
        <cxx-throws para_num="8" id="memory.resource.priv.8">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="9" id="memory.resource.priv.9">
    
    <pre><code><cxx-signature>virtual bool do_is_equal(const memory_resource&amp; other) const noexcept = 0;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="10" id="memory.resource.priv.10">
    
    <dt>Returns:</dt><dd>A derived class shall implement this function to return <code>true</code> if memory allocated from this can be deallocated from other and vice-versa;
        otherwise it shall return false.
        <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The most-derived type of other might not match the type of this.
        For a derived class, D, a typical implementation of this function will compute <code>dynamic_cast&lt;const D*&gt;(&amp;other)</code> and go no further (i.e., return <code>false</code>) if it returns <code>nullptr</code>.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.eq">
    

    <section>
      <header><span class="section-number">8.5.4</span> <h1 data-bookmark-label="8.5.4 memory_resource equality"><code>memory_resource</code> equality</h1> <span style="float:right"><a href="#memory.resource.eq">[memory.resource.eq]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.eq.1">
    
    <pre><code><cxx-signature>bool operator==(const memory_resource&amp; a, const memory_resource&amp; b) noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="2" id="memory.resource.eq.2">
    
    <dt>Returns:</dt><dd><code>&amp;a == &amp;b || a.is_equal(b)</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.resource.eq.3">
    
    <pre><code><cxx-signature>bool operator!=(const memory_resource&amp; a, const memory_resource&amp; b) noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="4" id="memory.resource.eq.4">
    
    <dt>Returns:</dt><dd><code>!(a == b)</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.polymorphic.allocator.class">
    

    <section>
      <header><span class="section-number">8.6</span> <h1 data-bookmark-label="8.6 Class template polymorphic_allocator">Class template <code>polymorphic_allocator</code></h1> <span style="float:right"><a href="#memory.polymorphic.allocator.class">[memory.polymorphic.allocator.class]</a></span></header>
      
    

    <cxx-section id="memory.polymorphic.allocator.overview">
    

    <section>
      <header><span class="section-number">8.6.1</span> <h1 data-bookmark-label="8.6.1 Class template polymorphic_allocator overview">Class template <code>polymorphic_allocator</code> overview</h1> <span style="float:right"><a href="#memory.polymorphic.allocator.overview">[memory.polymorphic.allocator.overview]</a></span></header>
      
      

      <p para_num="1" id="memory.polymorphic.allocator.overview.1">
        A specialization of class template <code>pmr::polymorphic_allocator</code> conforms to the <code>Allocator</code> requirements (<cxx-ref in="cxx" to="allocator.requirements">C++14 <span title="allocator.requirements">§17.6.3.5</span></cxx-ref>).
        Constructed with different memory resources, different instances of the same specialization of <code>pmr::polymorphic_allocator</code> can exhibit entirely different allocation behavior.
        This runtime polymorphism allows objects that use <code>polymorphic_allocator</code> to behave as if they used different allocator types at run time even though they use the same static allocator type.
      </p>

      <pre><code>template &lt;class Tp&gt;
class polymorphic_allocator {
  memory_resource* m_resource; // For exposition only

public:
  typedef Tp value_type;

  polymorphic_allocator() noexcept;
  polymorphic_allocator(memory_resource* r);

  polymorphic_allocator(const polymorphic_allocator&amp; other) = default;

  template &lt;class U&gt;
    polymorphic_allocator(const polymorphic_allocator&lt;U&gt;&amp; other) noexcept;

  polymorphic_allocator&amp;
    operator=(const polymorphic_allocator&amp; rhs) = default;

  Tp* allocate(size_t n);
  void deallocate(Tp* p, size_t n);

  template &lt;class T, class... Args&gt;
    void construct(T* p, Args&amp;&amp;... args);

  // Specializations for pair using piecewise construction
  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 std::pair&lt;U, V&gt;&amp; pr);
  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; pr);

  template &lt;class T&gt;
    void destroy(T* p);

  // Return a default-constructed allocator (no allocator propagation)
  polymorphic_allocator select_on_container_copy_construction() const;

  memory_resource* resource() const;
};</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.polymorphic.allocator.ctor">
    

    <section>
      <header><span class="section-number">8.6.2</span> <h1 data-bookmark-label="8.6.2 polymorphic_allocator constructors"><code>polymorphic_allocator</code> constructors</h1> <span style="float:right"><a href="#memory.polymorphic.allocator.ctor">[memory.polymorphic.allocator.ctor]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.polymorphic.allocator.ctor.1">
    
    <pre><code><cxx-signature>polymorphic_allocator() noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="2" id="memory.polymorphic.allocator.ctor.2">
    
    <dt>Effects:</dt><dd>Sets <code>m_resource</code> to <code>get_default_resource()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.polymorphic.allocator.ctor.3">
    
    <pre><code><cxx-signature>polymorphic_allocator(memory_resource* r);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="4" id="memory.polymorphic.allocator.ctor.4">
    
    <dt>Requires:</dt><dd><code>r</code> is non-null.</dd>
  </cxx-requires>
        <cxx-effects para_num="5" id="memory.polymorphic.allocator.ctor.5">
    
    <dt>Effects:</dt><dd>Sets <code>m_resource</code> to <code>r</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="6" id="memory.polymorphic.allocator.ctor.6">
    
    <dt>Throws:</dt><dd>Nothing</dd>
  </cxx-throws>
        <cxx-notes para_num="7" id="memory.polymorphic.allocator.ctor.7">
    
    <dt>Notes:</dt><dd>This constructor provides an implicit conversion from <code>memory_resource*</code>.</dd>
  </cxx-notes>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="8" id="memory.polymorphic.allocator.ctor.8">
    
    <pre><code><cxx-signature>template &lt;class U&gt;
polymorphic_allocator(const polymorphic_allocator&lt;U&gt;&amp; other) noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="9" id="memory.polymorphic.allocator.ctor.9">
    
    <dt>Effects:</dt><dd>Sets <code>m_resource</code> to <code>other.resource()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.polymorphic.allocator.mem">
    

    <section>
      <header><span class="section-number">8.6.3</span> <h1 data-bookmark-label="8.6.3 polymorphic_allocator member functions"><code>polymorphic_allocator</code> member functions</h1> <span style="float:right"><a href="#memory.polymorphic.allocator.mem">[memory.polymorphic.allocator.mem]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.polymorphic.allocator.mem.1">
    
    <pre><code><cxx-signature>Tp* allocate(size_t n);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="2" id="memory.polymorphic.allocator.mem.2">
    
    <dt>Returns:</dt><dd>Equivalent to <code>static_cast&lt;Tp*&gt;(m_resource-&gt;allocate(n * sizeof(Tp), alignof(Tp)))</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.polymorphic.allocator.mem.3">
    
    <pre><code><cxx-signature>void deallocate(Tp* p, size_t n);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-requires para_num="4" id="memory.polymorphic.allocator.mem.4">
    
    <dt>Requires:</dt><dd><code>p</code> was allocated from a memory resource, <code>x</code>, equal to <code>*m_resource</code>, using <code>x.allocate(n * sizeof(Tp), alignof(Tp))</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="5" id="memory.polymorphic.allocator.mem.5">
    
    <dt>Effects:</dt><dd>Equivalent to <code>m_resource-&gt;deallocate(p, n * sizeof(Tp), alignof(Tp))</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="6" id="memory.polymorphic.allocator.mem.6">
    
    <dt>Throws:</dt><dd>Nothing.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="7" id="memory.polymorphic.allocator.mem.7">
    
    <pre><code><cxx-signature>template &lt;class T, class... Args&gt;
void construct(T* p, Args&amp;&amp;... args);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-requires para_num="8" id="memory.polymorphic.allocator.mem.8">
    
    <dt>Requires:</dt><dd><cxx-term><i>Uses-allocator construction</i></cxx-term> of <code>T</code>
        with allocator <code>this-&gt;resource()</code> (see <cxx-ref to="mods.allocator.uses"><a title="mods.allocator.uses" href="#mods.allocator.uses">2.1</a></cxx-ref>)
        and constructor arguments <code>std::forward&lt;Args&gt;(args)...</code> is well-formed.
        <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    <cxx-term><i>uses-allocator construction</i></cxx-term> is always well formed for types that do not use allocators.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></dd>
  </cxx-requires>
        <cxx-effects para_num="9" id="memory.polymorphic.allocator.mem.9">
    
    <dt>Effects:</dt><dd>Construct a <code>T</code> object at <code>p</code> by <cxx-term><i>uses-allocator construction</i></cxx-term>
        with allocator <code>this-&gt;resource()</code> (<cxx-ref to="mods.allocator.uses"><a title="mods.allocator.uses" href="#mods.allocator.uses">2.1</a></cxx-ref>)
        and constructor arguments <code>std::forward&lt;Args&gt;(args)...</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="10" id="memory.polymorphic.allocator.mem.10">
    
    <dt>Throws:</dt><dd>: Nothing unless the constructor for <code>T</code> throws.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="11" id="memory.polymorphic.allocator.mem.11">
    
    <pre><code><cxx-signature>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);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="12" id="memory.polymorphic.allocator.mem.12">
    
    <dt>Effects:</dt><dd>
          Let <code>xprime</code> be a <code>tuple</code> constructed from <code>x</code> according to the appropriate rule from the following list.
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The following description can be summarized as constructing a <code>std::pair&lt;T1,T2&gt;</code> object at <code>p</code>
          as if by separate <i>uses-allocator construction</i> with allocator <code>this-&gt;resource()</code> (<cxx-ref to="mods.allocator.uses"><a title="mods.allocator.uses" href="#mods.allocator.uses">2.1</a></cxx-ref>)
          of <code>p-&gt;first</code> using the elements of <code>x</code>
          and <code>p-&gt;second</code> using the elements of <code>y</code>.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
          <ul>
            <li>If <code>uses_allocator_v&lt;T1,memory_resource*&gt;</code> is <code>false</code> and
            <code>is_constructible_v&lt;T,Args1...&gt;</code> is <code>true</code>, then <code>xprime</code> is <code>x</code>.</li>
            <li>Otherwise, if <code>uses_allocator_v&lt;T1,memory_resource*&gt;</code> is <code>true</code> and
            <code>is_constructible_v&lt;T1,allocator_arg_t,memory_resource*,Args1...&gt;</code> is <code>true</code>,
            then <code>xprime</code> is <code>tuple_cat(make_tuple(allocator_arg, this-&gt;resource()), std::move(x))</code>.</li>
            <li>Otherwise, if <code>uses_allocator_v&lt;T1,memory_resource*&gt;</code> is <code>true</code> and
            <code>is_constructible_v&lt;T1,Args1...,memory_resource*&gt;</code> is <code>true</code>,
            then <code>xprime</code> is <code>tuple_cat(std::move(x), make_tuple(this-&gt;resource()))</code>.</li>
            <li>Otherwise the program is ill formed.</li>
          </ul>
          and let yprime be a tuple constructed from y according to the appropriate rule from the following list:
          <ul>
            <li>If <code>uses_allocator_v&lt;T2,memory_resource*&gt;</code> is <code>false</code> and
            <code>is_constructible_v&lt;T,Args2...&gt;</code> is <code>true</code>, then <code>yprime</code> is <code>y</code>.</li>
            <li>Otherwise, if <code>uses_allocator_v&lt;T2,memory_resource*&gt;</code> is <code>true</code> and
            <code>is_constructible_v&lt;T2,allocator_arg_t,memory_resource*,Args2...&gt;</code> is <code>true</code>, then <code>yprime</code> is <code>tuple_cat(make_tuple(allocator_arg, this-&gt;resource()), std::move(y))</code>.</li>
            <li>Otherwise, if <code>uses_allocator_v&lt;T2,memory_resource*&gt;</code> is <code>true</code> and
            <code>is_constructible_v&lt;T2,Args2...,memory_resource*&gt;</code> is <code>true</code>, then
            <code>yprime</code> is <code>tuple_cat(std::move(y), make_tuple(this-&gt;resource()))</code>.</li>
            <li>Otherwise the program is ill formed.</li>
          </ul>
          then this function constructs a <code>std::pair&lt;T1,T2&gt;</code> object at <code>p</code> using constructor arguments <code>piecewise_construct, xprime, yprime</code>.
        </dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="13" id="memory.polymorphic.allocator.mem.13">
    
    <pre><code><cxx-signature>template &lt;class T1, class T2&gt;
void construct(std::pair&lt;T1,T2&gt;* p);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="14" id="memory.polymorphic.allocator.mem.14">
    
    <dt>Effects:</dt><dd>Equivalent to <code>this-&gt;construct(p, piecewise_construct, tuple&lt;&gt;(), tuple&lt;&gt;());</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="15" id="memory.polymorphic.allocator.mem.15">
    
    <pre><code><cxx-signature>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);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="16" id="memory.polymorphic.allocator.mem.16">
    
    <dt>Effects:</dt><dd>Equivalent to <code>this-&gt;construct(p, piecewise_construct, <w-br><wbr></w-br>forward_as_tuple(std::forward&lt;U&gt;(x)), <w-br><wbr></w-br>forward_as_tuple(std::forward&lt;V&gt;(y)));</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="17" id="memory.polymorphic.allocator.mem.17">
    
    <pre><code><cxx-signature>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; pr);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="18" id="memory.polymorphic.allocator.mem.18">
    
    <dt>Effects:</dt><dd>Equivalent to <code>this-&gt;construct(p, piecewise_construct, <w-br><wbr></w-br>forward_as_tuple(pr.first), <w-br><wbr></w-br>forward_as_tuple(pr.second));</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="19" id="memory.polymorphic.allocator.mem.19">
    
    <pre><code><cxx-signature>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; pr);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="20" id="memory.polymorphic.allocator.mem.20">
    
    <dt>Effects:</dt><dd>Equivalent to <code>this-&gt;construct(p, piecewise_construct,
        <w-br><wbr></w-br>forward_as_tuple(std::forward&lt;U&gt;(pr.first)),
        <w-br><wbr></w-br>forward_as_tuple(std::forward&lt;V&gt;(pr.second)));</code></dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="21" id="memory.polymorphic.allocator.mem.21">
    
    <pre><code><cxx-signature>template &lt;class T&gt;
void destroy(T* p);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="22" id="memory.polymorphic.allocator.mem.22">
    
    <dt>Effects:</dt><dd><code>p-&gt;~T()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="23" id="memory.polymorphic.allocator.mem.23">
    
    <pre><code><cxx-signature>polymorphic_allocator select_on_container_copy_construction() const;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="24" id="memory.polymorphic.allocator.mem.24">
    
    <dt>Returns:</dt><dd><code>polymorphic_allocator()</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="25" id="memory.polymorphic.allocator.mem.25">
    
    <pre><code><cxx-signature>memory_resource* resource() const;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="26" id="memory.polymorphic.allocator.mem.26">
    
    <dt>Returns:</dt><dd><code>m_resource</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.polymorphic.allocator.eq">
    

    <section>
      <header><span class="section-number">8.6.4</span> <h1 data-bookmark-label="8.6.4 polymorphic_allocator equality">polymorphic_allocator equality</h1> <span style="float:right"><a href="#memory.polymorphic.allocator.eq">[memory.polymorphic.allocator.eq]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.polymorphic.allocator.eq.1">
    
    <pre><code><cxx-signature>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;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="2" id="memory.polymorphic.allocator.eq.2">
    
    <dt>Returns:</dt><dd><code>*a.resource() == *b.resource()</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.polymorphic.allocator.eq.3">
    
    <pre><code><cxx-signature>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;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="4" id="memory.polymorphic.allocator.eq.4">
    
    <dt>Returns:</dt><dd><code>! (a == b)</code></dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource.adaptor">
    

    <section>
      <header><span class="section-number">8.7</span> <h1 data-bookmark-label="8.7 template alias resource_adaptor">template alias <code>resource_adaptor</code></h1> <span style="float:right"><a href="#memory.resource.adaptor">[memory.resource.adaptor]</a></span></header>
      
    

    <cxx-section id="memory.resource.adaptor.overview">
    

    <section>
      <header><span class="section-number">8.7.1</span> <h1 data-bookmark-label="8.7.1 resource_adaptor"><code>resource_adaptor</code></h1> <span style="float:right"><a href="#memory.resource.adaptor.overview">[memory.resource.adaptor.overview]</a></span></header>
      
      

      <p para_num="1" id="memory.resource.adaptor.overview.1">
        An instance of <code>resource_adaptor&lt;Allocator&gt;</code> is an adaptor that wraps a <code>memory_resource</code> interface around <code>Allocator</code>.
        In order that <code>resource_adaptor&lt;X&lt;T&gt;&gt;</code> and <code>resource_adaptor&lt;X&lt;U&gt;&gt;</code> are the same type for any allocator template <code>X</code> and types <code>T</code> and <code>U</code>,
        <code>resource_adaptor&lt;Allocator&gt;</code> is rendered as an alias to a class template such that <code>Allocator</code> is rebound to a <code>char</code> value type in every specialization of the class template.
        The requirements on this class template are defined below.
        The name <code><var>resource_adaptor_imp</var></code> is for exposition only and is not normative,
        but the definitions of the members of that class, whatever its name, are normative.
        In addition to the <code>Allocator</code> requirements (<cxx-ref in="cxx" to="allocator.requirements">C++14 <span title="allocator.requirements">§17.6.3.5</span></cxx-ref>), the parameter to <code>resource_adaptor</code> shall meet the following additional requirements:
      </p>
      <ul>
        <li><code>typename allocator_traits&lt;Allocator&gt;::pointer</code> shall be identical to <code>typename allocator_traits&lt;Allocator&gt;::value_type*</code>.</li>
        <li><code>typename allocator_traits&lt;Allocator&gt;::const_pointer</code> shall be identical to <code>typename allocator_traits&lt;Allocator&gt;::value_type const*</code>.</li>
        <li><code>typename allocator_traits&lt;Allocator&gt;::void_pointer</code> shall be identical to <code>void*</code>.</li>
        <li><code>typename allocator_traits&lt;Allocator&gt;::const_void_pointer</code> shall be identical to <code>void const*</code>.</li>
      </ul>

      <pre><code>
// The name <var>resource_adaptor_imp</var> is for exposition only.
template &lt;class Allocator&gt;
class <var>resource_adaptor_imp</var> : public memory_resource {
  // for exposition only
  Allocator m_alloc;

public:
  typedef Allocator allocator_type;

  <var>resource_adaptor_imp</var>() = default;
  <var>resource_adaptor_imp</var>(const <var>resource_adaptor_imp</var>&amp;) = default;
  <var>resource_adaptor_imp</var>(<var>resource_adaptor_imp</var>&amp;&amp;) = default;

  explicit <var>resource_adaptor_imp</var>(const Allocator&amp; a2);
  explicit <var>resource_adaptor_imp</var>(Allocator&amp;&amp; a2);

  <var>resource_adaptor_imp</var>&amp; operator=(const <var>resource_adaptor_imp</var>&amp;) = default;

  allocator_type get_allocator() const { return m_alloc; }

protected:
  virtual void* do_allocate(size_t bytes, size_t alignment);
  virtual void do_deallocate(void* p, size_t bytes, size_t alignment);

  virtual bool do_is_equal(const memory_resource&amp; other) const noexcept;
};

template &lt;class Allocator&gt;
  using resource_adaptor = typename <var>resource_adaptor_imp</var>&lt;
    allocator_traits&lt;Allocator&gt;::template rebind_alloc&lt;char&gt;&gt;;</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.adaptor.ctor">
    

    <section>
      <header><span class="section-number">8.7.2</span> <h1 data-bookmark-label="8.7.2 resource_adaptor_imp constructors"><code><var>resource_adaptor_imp</var></code> constructors</h1> <span style="float:right"><a href="#memory.resource.adaptor.ctor">[memory.resource.adaptor.ctor]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.adaptor.ctor.1">
    
    <pre><code><cxx-signature>explicit <var>resource_adaptor_imp</var>(const Allocator&amp; a2);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="2" id="memory.resource.adaptor.ctor.2">
    
    <dt>Effects:</dt><dd>Initializes <code>m_alloc</code> with <code>a2</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.resource.adaptor.ctor.3">
    
    <pre><code><cxx-signature>explicit <var>resource_adaptor_imp</var>(Allocator&amp;&amp; a2);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="4" id="memory.resource.adaptor.ctor.4">
    
    <dt>Effects:</dt><dd>Initializes <code>m_alloc</code> with <code>std::move(a2)</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.adaptor.mem">
    

    <section>
      <header><span class="section-number">8.7.3</span> <h1 data-bookmark-label="8.7.3 resource_adaptor_imp member functions"><code><var>resource_adaptor_imp</var></code> member functions</h1> <span style="float:right"><a href="#memory.resource.adaptor.mem">[memory.resource.adaptor.mem]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.adaptor.mem.1">
    
    <pre><code><cxx-signature>void* do_allocate(size_t bytes, size_t alignment);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="2" id="memory.resource.adaptor.mem.2">
    
    <dt>Returns:</dt><dd>Allocated memory obtained by calling <code>m_alloc.allocate</code>. The size and alignment of the allocated memory shall meet the requirements for a class derived from <code>memory_resource</code> (<cxx-ref to="memory.resource"><a title="memory.resource" href="#memory.resource">8.5</a></cxx-ref>).</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.resource.adaptor.mem.3">
    
    <pre><code><cxx-signature>void do_deallocate(void* p, size_t bytes, size_t alignment);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-requires para_num="4" id="memory.resource.adaptor.mem.4">
    
    <dt>Requires:</dt><dd><code>p</code> was previously allocated using <code>A.allocate</code>, where <code>A == m_alloc</code>, and not subsequently deallocated.</dd>
  </cxx-requires>
        <cxx-effects para_num="5" id="memory.resource.adaptor.mem.5">
    
    <dt>Effects:</dt><dd>Returns memory to the allocator using <code>m_alloc.deallocate()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="memory.resource.adaptor.mem.6">
    
    <pre><code><cxx-signature>bool do_is_equal(const memory_resource&amp; other) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        <p para_num="7" id="memory.resource.adaptor.mem.7">Let <code>p</code> be <code>dynamic_cast&lt;const <var>resource_adaptor_imp</var>*&gt;(&amp;other)</code>.</p>
        <cxx-returns para_num="8" id="memory.resource.adaptor.mem.8">
    
    <dt>Returns:</dt><dd><code>false</code> if <code>p</code> is null, otherwise the value of <code>m_alloc == p-&gt;m_alloc</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource.global">
    

    <section>
      <header><span class="section-number">8.8</span> <h1 data-bookmark-label="8.8 Access to program-wide memory_resource objects">Access to program-wide <code>memory_resource</code> objects</h1> <span style="float:right"><a href="#memory.resource.global">[memory.resource.global]</a></span></header>
      
    

    <cxx-function para_num="1" id="memory.resource.global.1">
    
    <pre><code><cxx-signature>memory_resource* new_delete_resource() noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="2" id="memory.resource.global.2">
    
    <dt>Returns:</dt><dd>A pointer to a static-duration object of a type derived from <code>memory_resource</code> that can serve as a resource for allocating memory using <code>::operator new</code> and <code>::operator delete</code>. The same value is returned every time this function is called. For return value <code>p</code> and memory resource <code>r</code>, <code>p-&gt;is_equal(r)</code> returns <code>&amp;r == p</code>.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="3" id="memory.resource.global.3">
    
    <pre><code><cxx-signature>memory_resource* null_memory_resource() noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-returns para_num="4" id="memory.resource.global.4">
    
    <dt>Returns:</dt><dd>
        A pointer to a static-duration object of a type derived from <code>memory_resource</code>
        for which <code>allocate()</code> always throws <code>bad_alloc</code> and
        for which <code>deallocate()</code> has no effect.
        The same value is returned every time this function is called.
        For return value <code>p</code> and memory resource <code>r</code>, <code>p-&gt;is_equal(r)</code> returns <code>&amp;r == p</code>.
      </dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>

    <p para_num="5" id="memory.resource.global.5">
      The <dfn>default memory resource pointer</dfn> is a pointer to a memory resource
      that is used by certain facilities when an explicit memory resource is not supplied through the interface.
      Its initial value is the return value of <code>new_delete_resource()</code>.
    </p>

    <cxx-function para_num="6" id="memory.resource.global.6">
    
    <pre><code><cxx-signature>memory_resource* set_default_resource(memory_resource* r) noexcept;</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="7" id="memory.resource.global.7">
    
    <dt>Effects:</dt><dd>
        If <code>r</code> is non-null, sets the value of the default memory resource pointer to <code>r</code>,
        otherwise sets the default memory resource pointer to <code>new_delete_resource()</code>.
      </dd>
  </cxx-effects>
      <cxx-postconditions para_num="8" id="memory.resource.global.8">
    
    <dt>Postconditions:</dt><dd><code>get_default_resource() == r</code>.</dd>
  </cxx-postconditions>
      <cxx-returns para_num="9" id="memory.resource.global.9">
    
    <dt>Returns:</dt><dd>The previous value of the default memory resource pointer.</dd>
  </cxx-returns>
      <cxx-remarks para_num="10" id="memory.resource.global.10">
    
    <dt>Remarks:</dt><dd>
        Calling the <code>set_default_resource</code> and <code>get_default_resource</code> functions shall not incur a data race.
        A call to the <code>set_default_resource</code> function shall synchronize with subsequent calls to the <code>set_default_resource</code> and <code>get_default_resource</code> functions.
      </dd>
  </cxx-remarks>
    
    </dl>
  </cxx-function>

    <cxx-function para_num="11" id="memory.resource.global.11">
    
    <pre><code><cxx-signature>memory_resource* get_default_resource() noexcept;</cxx-signature></code></pre>

    <dl>
      
      
      <cxx-returns para_num="12" id="memory.resource.global.12">
    
    <dt>Returns:</dt><dd>The current value of the default memory resource pointer.</dd>
  </cxx-returns>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource.pool">
    

    <section>
      <header><span class="section-number">8.9</span> <h1 data-bookmark-label="8.9 Pool resource classes">Pool resource classes</h1> <span style="float:right"><a href="#memory.resource.pool">[memory.resource.pool]</a></span></header>
      
    

    <cxx-section id="memory.resource.pool.overview">
    

    <section>
      <header><span class="section-number">8.9.1</span> <h1 data-bookmark-label="8.9.1 Classes synchronized_pool_resource and unsynchronized_pool_resource">Classes <code>synchronized_pool_resource</code> and <code>unsynchronized_pool_resource</code></h1> <span style="float:right"><a href="#memory.resource.pool.overview">[memory.resource.pool.overview]</a></span></header>
      
      

      <p para_num="1" id="memory.resource.pool.overview.1">
        The <code>synchronized_pool_resource</code> and <code>unsynchronized_pool_resource</code> classes (collectively, <dfn>pool resource classes</dfn>)
        are general-purpose memory resources having the following qualities:
      </p>
      <ul>
        <li>Each resource <cxx-term><i>owns</i></cxx-term> the allocated memory, and frees it on destruction –
        even if <code>deallocate</code> has not been called for some of the allocated blocks.</li>
        <li>A pool resource (see <cxx-ref to="fig:memory.resource.pool.resources"><a title="fig:memory.resource.pool.resources" href="#fig:memory.resource.pool.resources">Figure 1</a></cxx-ref>) consists of a collection of <dfn>pools</dfn>, serving requests for different block sizes.
        Each individual pool manages a collection of <dfn>chunks</dfn> that are in turn divided into blocks of uniform size, returned via calls to <code>do_allocate</code>.
        Each call to <code>do_allocate(size, alignment)</code> is dispatched to the pool serving the smallest blocks accommodating at least <code>size</code> bytes.</li>
        <li>When a particular pool is exhausted, allocating a block from that pool results in the allocation of an additional chunk of memory from the <dfn>upstream allocator</dfn> (supplied at construction), thus replenishing the pool.
        With each successive replenishment, the chunk size obtained increases geometrically.
        <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    By allocating memory in chunks, the pooling strategy increases the chance that consecutive allocations will be close together in memory.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></li>
        <li>Allocation requests that exceed the largest block size of any pool are fulfilled directly from the upstream allocator.</li>
        <li>A <code>pool_options</code> struct may be passed to the pool resource constructors to tune the largest block size and the maximum chunk size.</li>
      </ul>
      <cxx-example>
    
    <span class="nowrap">[ <em>Example:</em></span>
    <cxx-ref to="fig:memory.resource.pool.resources"><a title="fig:memory.resource.pool.resources" href="#fig:memory.resource.pool.resources">Figure 1</a></cxx-ref> shows a possible data structure that implements a pool resource.
      <cxx-figure id="fig:memory.resource.pool.resources">
    
    <figure>
      <figcaption>Figure 1 — <wbr><figcaption>pool resource</figcaption></figcaption>
      
        <img src="data:image/png;base64,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" width="100%">
        
      
    </figure>
  </cxx-figure>
      
    <span class="nowrap">— <em>end example</em> ]</span>
  </cxx-example>

      <p para_num="2" id="memory.resource.pool.overview.2">
        A <code>synchronized_pool_resource</code> may be accessed from multiple threads without external synchronization
        and may have thread-specific pools to reduce synchronization costs.
        An <code>unsynchronized_pool_resource</code> class may not be accessed from multiple threads simultaneously
        and thus avoids the cost of synchronization entirely in single-threaded applications.
      </p>

<pre><code>struct pool_options {
  size_t max_blocks_per_chunk = 0;
  size_t largest_required_pool_block = 0;
};

class synchronized_pool_resource : public memory_resource {
public:
  synchronized_pool_resource(const pool_options&amp; opts, memory_resource* upstream);

  synchronized_pool_resource()
      : synchronized_pool_resource(pool_options(), get_default_resource()) { }
  explicit synchronized_pool_resource(memory_resource* upstream)
      : synchronized_pool_resource(pool_options(), upstream) { }
  explicit synchronized_pool_resource(const pool_options&amp; opts)
      : synchronized_pool_resource(opts, get_default_resource()) { }

  synchronized_pool_resource(
      const synchronized_pool_resource&amp;) = delete;
  virtual ~synchronized_pool_resource();

  synchronized_pool_resource&amp; operator=(
      const synchronized_pool_resource&amp;) = delete;

  void release();
  memory_resource* upstream_resource() const;
  pool_options options() const;

protected:
  virtual void* do_allocate(size_t bytes, size_t alignment);
  virtual void do_deallocate(void* p, size_t bytes, size_t alignment);

  virtual bool do_is_equal(const memory_resource&amp; other) const noexcept;
};

class unsynchronized_pool_resource : public memory_resource {
public:
  unsynchronized_pool_resource(const pool_options&amp; opts, memory_resource* upstream);

  unsynchronized_pool_resource()
      : unsynchronized_pool_resource(pool_options(), get_default_resource()) { }
  explicit unsynchronized_pool_resource(memory_resource* upstream)
      : unsynchronized_pool_resource(pool_options(), upstream) { }
  explicit unsynchronized_pool_resource(const pool_options&amp; opts)
      : unsynchronized_pool_resource(opts, get_default_resource()) { }

  unsynchronized_pool_resource(
      const unsynchronized_pool_resource&amp;) = delete;
  virtual ~unsynchronized_pool_resource();

  unsynchronized_pool_resource&amp; operator=(
      const unsynchronized_pool_resource&amp;) = delete;

  void release();
  memory_resource* upstream_resource() const;
  pool_options options() const;

protected:
  virtual void* do_allocate(size_t bytes, size_t alignment);
  virtual void do_deallocate(void* p, size_t bytes, size_t alignment);

  virtual bool do_is_equal(const memory_resource&amp; other) const noexcept;
};</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.pool.options">
    

    <section>
      <header><span class="section-number">8.9.2</span> <h1 data-bookmark-label="8.9.2 pool_options data members"><code>pool_options</code> data members</h1> <span style="float:right"><a href="#memory.resource.pool.options">[memory.resource.pool.options]</a></span></header>
      
      

      <p para_num="1" id="memory.resource.pool.options.1">
        The members of <code>pool_options</code> comprise a set of constructor options for pool resources.
        The effect of each option on the pool resource behavior is described below:
      </p>

      <cxx-function para_num="2" id="memory.resource.pool.options.2">
    
    <pre><code><cxx-signature>size_t max_blocks_per_chunk;</cxx-signature></code></pre>

    <dl>
      
        

        <p para_num="3" id="memory.resource.pool.options.3">
          The maximum number of blocks that will be allocated at once from the upstream memory resource to replenish a pool.
          If the value of <code>max_blocks_per_chunk</code> is zero or is greater than an implementation-defined limit, that limit is used instead.
          The implementation may choose to use a smaller value than is specified in this field and may use different values for different pools.
        </p>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="4" id="memory.resource.pool.options.4">
    
    <pre><code><cxx-signature>size_t largest_required_pool_block;</cxx-signature></code></pre>

    <dl>
      
        

        <p para_num="5" id="memory.resource.pool.options.5">
          The largest allocation size that is required to be fulfilled using the pooling mechanism.
          Attempts to allocate a single block larger than this threshold will be allocated directly from the upstream memory resource.
          If <code>largest_required_pool_block</code> is zero or is greater than an implementation-defined limit, that limit is used instead.
          The implementation may choose a pass-through threshold larger than specified in this field.
        </p>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.pool.ctor">
    

    <section>
      <header><span class="section-number">8.9.3</span> <h1 data-bookmark-label="8.9.3 pool resource constructors and destructors">pool resource constructors and destructors</h1> <span style="float:right"><a href="#memory.resource.pool.ctor">[memory.resource.pool.ctor]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.pool.ctor.1">
    
    <pre><code><cxx-signature>synchronized_pool_resource(const pool_options&amp; opts, memory_resource* upstream);</cxx-signature><cxx-signature>unsynchronized_pool_resource(const pool_options&amp; opts, memory_resource* upstream);</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-requires para_num="2" id="memory.resource.pool.ctor.2">
    
    <dt>Requires:</dt><dd><code>upstream</code> is the address of a valid memory resource.</dd>
  </cxx-requires>
        <cxx-effects para_num="3" id="memory.resource.pool.ctor.3">
    
    <dt>Effects:</dt><dd>
          Constructs a pool resource object that will obtain memory from <code>upstream</code> whenever the pool resource is unable to satisfy a memory request from its own internal data structures.
          The resulting object will hold a copy of <code>upstream</code>, but will not own the resource to which <code>upstream</code> points.
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    The intention is that calls to <code>upstream-&gt;allocate()</code> will be substantially fewer than calls to <code>this-&gt;allocate()</code> in most cases.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
          The behavior of the pooling mechanism is tuned according to the value of the opts argument.
        </dd>
  </cxx-effects>
        <cxx-throws para_num="4" id="memory.resource.pool.ctor.4">
    
    <dt>Throws:</dt><dd>Nothing unless <code>upstream-&gt;allocate()</code> throws.
        It is unspecified if or under what conditions this constructor calls <code>upstream-&gt;allocate()</code>.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="memory.resource.pool.ctor.5">
    
    <pre><code><cxx-signature>virtual ~synchronized_pool_resource();</cxx-signature><cxx-signature>virtual ~unsynchronized_pool_resource();</cxx-signature></code></pre>

    <dl>
      
        
        
        <cxx-effects para_num="6" id="memory.resource.pool.ctor.6">
    
    <dt>Effects:</dt><dd>Calls <code>this-&gt;release()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.pool.mem">
    

    <section>
      <header><span class="section-number">8.9.4</span> <h1 data-bookmark-label="8.9.4 pool resource members">pool resource members</h1> <span style="float:right"><a href="#memory.resource.pool.mem">[memory.resource.pool.mem]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.pool.mem.1">
    
    <pre><code><cxx-signature>void release();</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="2" id="memory.resource.pool.mem.2">
    
    <dt>Effects:</dt><dd>
          Calls <code>upstream_resource()-&gt;deallocate()</code> as necessary to release all allocated memory.
          <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    memory is released back to <code>upstream_resource()</code> even if <code>deallocate</code> has not been called for some of the allocated blocks.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note>
        </dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="3" id="memory.resource.pool.mem.3">
    
    <pre><code><cxx-signature>memory_resource* upstream_resource() const;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="4" id="memory.resource.pool.mem.4">
    
    <dt>Returns:</dt><dd>The value of the <code>upstream</code> argument provided to the constructor of this object.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="5" id="memory.resource.pool.mem.5">
    
    <pre><code><cxx-signature>pool_options options() const;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="6" id="memory.resource.pool.mem.6">
    
    <dt>Returns:</dt><dd>
          The options that control the pooling behavior of this resource.
          The values in the returned struct may differ from those supplied to the pool resource constructor
          in that values of zero will be replaced with implementation-defined defaults and sizes may be rounded to unspecified granularity.
        </dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="7" id="memory.resource.pool.mem.7">
    
    <pre><code><cxx-signature>virtual void* do_allocate(size_t bytes, size_t alignment);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="8" id="memory.resource.pool.mem.8">
    
    <dt>Returns:</dt><dd>A pointer to allocated storage (<cxx-ref in="cxx" to="basic.stc.dynamic.deallocation">C++14 <span title="basic.stc.dynamic.deallocation">§3.7.4.2</span></cxx-ref>) with a size of at least <code>bytes</code>.
        The size and alignment of the allocated memory shall meet the requirements for a class derived from <code>memory_resource</code> (<cxx-ref to="memory.resource"><a title="memory.resource" href="#memory.resource">8.5</a></cxx-ref>).</dd>
  </cxx-returns>
        <cxx-effects para_num="9" id="memory.resource.pool.mem.9">
    
    <dt>Effects:</dt><dd>
          If the pool selected for a block of size <code>bytes</code> is unable to satisfy the memory request from its own internal data structures,
          it will call <code>upstream_resource()-&gt;allocate()</code> to obtain more memory.
          If <code>bytes</code> is larger than that which the largest pool can handle,
          then memory will be allocated using <code>upstream_resource()-&gt;allocate()</code>.
        </dd>
  </cxx-effects>
        <cxx-throws para_num="10" id="memory.resource.pool.mem.10">
    
    <dt>Throws:</dt><dd>Nothing unless <code>upstream_resource()-&gt;allocate()</code> throws.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="11" id="memory.resource.pool.mem.11">
    
    <pre><code><cxx-signature>virtual void do_deallocate(void* p, size_t bytes, size_t alignment);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-effects para_num="12" id="memory.resource.pool.mem.12">
    
    <dt>Effects:</dt><dd>Return the memory at <code>p</code> to the pool.
        It is unspecified if or under what circumstances this operation will result in a call to <code>upstream_resource()-&gt;deallocate()</code>.</dd>
  </cxx-effects>
        <cxx-throws para_num="13" id="memory.resource.pool.mem.13">
    
    <dt>Throws:</dt><dd>Nothing</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="14" id="memory.resource.pool.mem.14">
    
    <pre><code><cxx-signature>virtual bool unsynchronized_pool_resource::do_is_equal(<w-br><wbr></w-br>const memory_resource&amp; other) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="15" id="memory.resource.pool.mem.15">
    
    <dt>Returns:</dt><dd><code>this == dynamic_cast&lt;const unsynchronized_pool_resource*&gt;(&amp;other)</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="16" id="memory.resource.pool.mem.16">
    
    <pre><code><cxx-signature>virtual bool synchronized_pool_resource::do_is_equal(<w-br><wbr></w-br>const memory_resource&amp; other) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="17" id="memory.resource.pool.mem.17">
    
    <dt>Returns:</dt><dd><code>this == dynamic_cast&lt;const synchronized_pool_resource*&gt;(&amp;other)</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource.monotonic.buffer">
    

    <section>
      <header><span class="section-number">8.10</span> <h1 data-bookmark-label="8.10 Class monotonic_buffer_resource">Class <code>monotonic_buffer_resource</code></h1> <span style="float:right"><a href="#memory.resource.monotonic.buffer">[memory.resource.monotonic.buffer]</a></span></header>
      
    

    <cxx-section id="memory.resource.monotonic.buffer.overview">
    

    <section>
      <header><span class="section-number">8.10.1</span> <h1 data-bookmark-label="8.10.1 Class monotonic_buffer_resource overview">Class <code>monotonic_buffer_resource</code> overview</h1> <span style="float:right"><a href="#memory.resource.monotonic.buffer.overview">[memory.resource.monotonic.buffer.overview]</a></span></header>
      
      

      <p para_num="1" id="memory.resource.monotonic.buffer.overview.1">
        A <code>monotonic_buffer_resource</code> is a special-purpose 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 memory resource object is destroyed.
        It has the following qualities:
      </p>
      <ul>
        <li>A call to <code>deallocate</code> has no effect,
        thus the amount of memory consumed increases monotonically until the resource is destroyed.</li>
        <li>The program can supply an initial buffer, which the allocator uses to satisfy memory requests.</li>
        <li>When the initial buffer (if any) is exhausted,
        it obtains additional buffers from an <dfn>upstream</dfn> memory resource supplied at construction.
        Each additional buffer is larger than the previous one, following a geometric progression.</li>
        <li>It is intended for access from one thread of control at a time.
        Specifically, calls to <code>allocate</code> and <code>deallocate</code> do not synchronize with one another.</li>
        <li>It <cxx-term><i>owns</i></cxx-term> the allocated memory and frees it on destruction,
        even if <code>deallocate</code> has not been called for some of the allocated blocks.</li>
      </ul>
<pre><code>class monotonic_buffer_resource : public memory_resource {
  memory_resource* upstream_rsrc; // exposition only
  void* current_buffer; // exposition only
  size_t next_buffer_size; // exposition only

public:
  explicit monotonic_buffer_resource(memory_resource* upstream);
  monotonic_buffer_resource(size_t initial_size,
                            memory_resource* upstream);
  monotonic_buffer_resource(void* buffer, size_t buffer_size,
                            memory_resource* upstream);

  monotonic_buffer_resource()
      : monotonic_buffer_resource(get_default_resource()) { }
  explicit monotonic_buffer_resource(size_t initial_size)
      : monotonic_buffer_resource(initial_size,
                                  get_default_resource()) { }
  monotonic_buffer_resource(void* buffer, size_t buffer_size)
      : monotonic_buffer_resource(buffer, buffer_size,
                                  get_default_resource()) { }

  monotonic_buffer_resource(const monotonic_buffer_resource&amp;) = delete;

  virtual ~monotonic_buffer_resource();

  monotonic_buffer_resource operator=(
      const monotonic_buffer_resource&amp;) = delete;

  void release();
  memory_resource* upstream_resource() const;

protected:
  virtual void* do_allocate(size_t bytes, size_t alignment);
  virtual void do_deallocate(void* p, size_t bytes,
                             size_t alignment);

  virtual bool do_is_equal(const memory_resource&amp; other) const noexcept;
};</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.monotonic.buffer.ctor">
    

    <section>
      <header><span class="section-number">8.10.2</span> <h1 data-bookmark-label="8.10.2 monotonic_buffer_resource constructor and destructor"><code>monotonic_buffer_resource</code> constructor and destructor</h1> <span style="float:right"><a href="#memory.resource.monotonic.buffer.ctor">[memory.resource.monotonic.buffer.ctor]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.monotonic.buffer.ctor.1">
    
    <pre><code><cxx-signature>explicit monotonic_buffer_resource(memory_resource* upstream);</cxx-signature><cxx-signature>monotonic_buffer_resource(size_t initial_size, memory_resource* upstream);</cxx-signature></code></pre>

    <dl>
      
        
        

        <cxx-requires para_num="2" id="memory.resource.monotonic.buffer.ctor.2">
    
    <dt>Requires:</dt><dd><code>upstream</code> shall be the address of a valid memory resource.
        <code>initial_size</code>, if specified, shall be greater than zero.</dd>
  </cxx-requires>
        <cxx-effects para_num="3" id="memory.resource.monotonic.buffer.ctor.3">
    
    <dt>Effects:</dt><dd>Sets <code>upstream_rsrc</code> to <code>upstream</code> and <code>current_buffer</code> to <code>nullptr</code>.
        If <code>initial_size</code> is specified, sets <code>next_buffer_size</code> to at least <code>initial_size</code>;
        otherwise sets <code>next_buffer_size</code> to an implementation-defined size.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="4" id="memory.resource.monotonic.buffer.ctor.4">
    
    <pre><code><cxx-signature>monotonic_buffer_resource(void* buffer, size_t buffer_size, memory_resource* upstream);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-requires para_num="5" id="memory.resource.monotonic.buffer.ctor.5">
    
    <dt>Requires:</dt><dd><code>upstream</code> shall be the address of a valid memory resource.
        <code>buffer_size</code> shall be no larger than the number of bytes in <code>buffer</code>.</dd>
  </cxx-requires>
        <cxx-effects para_num="6" id="memory.resource.monotonic.buffer.ctor.6">
    
    <dt>Effects:</dt><dd>Sets <code>upstream_rsrc</code> to <code>upstream</code>, <code>current_buffer</code> to <code>buffer</code>, and <code>next_buffer_size</code> to <code>initial_size</code> (but not less than 1),
        then increases <code>next_buffer_size</code> by an implementation-defined growth factor (which need not be integral).</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="7" id="memory.resource.monotonic.buffer.ctor.7">
    
    <pre><code><cxx-signature>~monotonic_buffer_resource();</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="8" id="memory.resource.monotonic.buffer.ctor.8">
    
    <dt>Effects:</dt><dd>Calls <code>this-&gt;release()</code>.</dd>
  </cxx-effects>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>

    <cxx-section id="memory.resource.monotonic.buffer.mem">
    

    <section>
      <header><span class="section-number">8.10.3</span> <h1 data-bookmark-label="8.10.3 monotonic_buffer_resource members">monotonic_buffer_resource members</h1> <span style="float:right"><a href="#memory.resource.monotonic.buffer.mem">[memory.resource.monotonic.buffer.mem]</a></span></header>
      
      

      <cxx-function para_num="1" id="memory.resource.monotonic.buffer.mem.1">
    
    <pre><code><cxx-signature>void release();</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="2" id="memory.resource.monotonic.buffer.mem.2">
    
    <dt>Effects:</dt><dd>Calls <code>upstream_rsrc-&gt;deallocate()</code> as necessary to release all allocated memory.</dd>
  </cxx-effects>
        <p para_num="3" id="memory.resource.monotonic.buffer.mem.3"><cxx-note><span class="nowrap">[ <em>Note:</em></span>
    memory is released back to <code>upstream_rsrc</code> even if some blocks that were allocated from <code>this</code> have not been deallocated from <code>this</code>.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></p>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="4" id="memory.resource.monotonic.buffer.mem.4">
    
    <pre><code><cxx-signature>memory_resource* upstream_resource() const;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="5" id="memory.resource.monotonic.buffer.mem.5">
    
    <dt>Returns:</dt><dd>The value of <code>upstream_rsrc</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="6" id="memory.resource.monotonic.buffer.mem.6">
    
    <pre><code><cxx-signature>void* do_allocate(size_t bytes, size_t alignment);</cxx-signature></code></pre>

    <dl>
      
        

        <cxx-returns para_num="7" id="memory.resource.monotonic.buffer.mem.7">
    
    <dt>Returns:</dt><dd>A pointer to allocated storage (<cxx-ref in="cxx" to="basic.stc.dynamic.deallocation">C++14 <span title="basic.stc.dynamic.deallocation">§3.7.4.2</span></cxx-ref>) with a size of at least <code>bytes</code>.
        The size and alignment of the allocated memory shall meet the requirements for a class derived from <code>memory_resource</code> (<cxx-ref to="memory.resource"><a title="memory.resource" href="#memory.resource">8.5</a></cxx-ref>).</dd>
  </cxx-returns>
        <cxx-effects para_num="8" id="memory.resource.monotonic.buffer.mem.8">
    
    <dt>Effects:</dt><dd>
          If the unused space in <code>current_buffer</code> can fit a block with the specified <code>bytes</code> and <code>alignment</code>,
          then allocate the return block from <code>current_buffer</code>;
          otherwise set <code>current_buffer</code> to <code>upstream_rsrc-&gt;allocate(n, m)</code>,
          where <code>n</code> is not less than <code>max(bytes, next_buffer_size)</code> and <code>m</code> is not less than <code>alignment</code>,
          and increase <code>next_buffer_size</code> by an implementation-defined growth factor (which need not be integral),
          then allocate the return block from the newly-allocated <code>current_buffer</code>.
        </dd>
  </cxx-effects>
        <cxx-throws para_num="9" id="memory.resource.monotonic.buffer.mem.9">
    
    <dt>Throws:</dt><dd>Nothing unless <code>upstream_rsrc-&gt;allocate()</code> throws.</dd>
  </cxx-throws>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="10" id="memory.resource.monotonic.buffer.mem.10">
    
    <pre><code><cxx-signature>void do_deallocate(void* p, size_t bytes, size_t alignment);</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-effects para_num="11" id="memory.resource.monotonic.buffer.mem.11">
    
    <dt>Effects:</dt><dd>None</dd>
  </cxx-effects>
        <cxx-throws para_num="12" id="memory.resource.monotonic.buffer.mem.12">
    
    <dt>Throws:</dt><dd>Nothing</dd>
  </cxx-throws>
        <cxx-remarks para_num="13" id="memory.resource.monotonic.buffer.mem.13">
    
    <dt>Remarks:</dt><dd>Memory used by this resource increases monotonically until its destruction.</dd>
  </cxx-remarks>
      
    </dl>
  </cxx-function>

      <cxx-function para_num="14" id="memory.resource.monotonic.buffer.mem.14">
    
    <pre><code><cxx-signature>bool do_is_equal(const memory_resource&amp; other) const noexcept;</cxx-signature></code></pre>

    <dl>
      
        
        <cxx-returns para_num="15" id="memory.resource.monotonic.buffer.mem.15">
    
    <dt>Returns:</dt><dd><code>this == dynamic_cast&lt;const monotonic_buffer_resource*&gt;(&amp;other)</code>.</dd>
  </cxx-returns>
      
    </dl>
  </cxx-function>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

  <cxx-section id="memory.resource.aliases">
    

    <section>
      <header><span class="section-number">8.11</span> <h1 data-bookmark-label="8.11 Alias templates using polymorphic memory resources">Alias templates using polymorphic memory resources</h1> <span style="float:right"><a href="#memory.resource.aliases">[memory.resource.aliases]</a></span></header>
      
    

    <cxx-section id="header.string.synop">
    

    <section>
      <header><span class="section-number">8.11.1</span> <h1 data-bookmark-label="8.11.1 Header <experimental/string> synopsis">Header &lt;experimental/string&gt; synopsis</h1> <span style="float:right"><a href="#header.string.synop">[header.string.synop]</a></span></header>
      
      
<pre><code>#include &lt;string&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  // basic_string using polymorphic allocator in namespace pmr
  template &lt;class charT, class traits = char_traits&lt;charT&gt;&gt;
   using basic_string =
     std::basic_string&lt;charT, traits, polymorphic_allocator&lt;charT&gt;&gt;;

  // basic_string typedef names using polymorphic allocator in namespace
  // std::experimental::pmr
  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;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.deque.synop">
    

    <section>
      <header><span class="section-number">8.11.2</span> <h1 data-bookmark-label="8.11.2 Header <experimental/deque> synopsis">Header &lt;experimental/deque&gt; synopsis</h1> <span style="float:right"><a href="#header.deque.synop">[header.deque.synop]</a></span></header>
      
      
<pre><code>#include &lt;deque&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class T&gt;
  using deque = std::deque&lt;T,polymorphic_allocator&lt;T&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.forward_list.synop">
    

    <section>
      <header><span class="section-number">8.11.3</span> <h1 data-bookmark-label="8.11.3 Header <experimental/forward_list> synopsis">Header &lt;experimental/forward_list&gt; synopsis</h1> <span style="float:right"><a href="#header.forward_list.synop">[header.forward_list.synop]</a></span></header>
      
      
<pre><code>#include &lt;forward_list&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class T&gt;
  using forward_list =
    std::forward_list&lt;T,polymorphic_allocator&lt;T&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.list.synop">
    

    <section>
      <header><span class="section-number">8.11.4</span> <h1 data-bookmark-label="8.11.4 Header <experimental/list> synopsis">Header &lt;experimental/list&gt; synopsis</h1> <span style="float:right"><a href="#header.list.synop">[header.list.synop]</a></span></header>
      
      
<pre><code>#include &lt;list&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class T&gt;
  using list = std::list&lt;T,polymorphic_allocator&lt;T&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.vector.synop">
    

    <section>
      <header><span class="section-number">8.11.5</span> <h1 data-bookmark-label="8.11.5 Header <experimental/vector> synopsis">Header &lt;experimental/vector&gt; synopsis</h1> <span style="float:right"><a href="#header.vector.synop">[header.vector.synop]</a></span></header>
      
      
<pre><code>#include &lt;vector&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class T&gt;
  using vector = std::vector&lt;T,polymorphic_allocator&lt;T&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.map.synop">
    

    <section>
      <header><span class="section-number">8.11.6</span> <h1 data-bookmark-label="8.11.6 Header <experimental/map> synopsis">Header &lt;experimental/map&gt; synopsis</h1> <span style="float:right"><a href="#header.map.synop">[header.map.synop]</a></span></header>
      
      
<pre><code>#include &lt;map&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class Key, class T, class Compare = less&lt;Key&gt;&gt;
  using map = std::map&lt;Key, T, Compare,
                       polymorphic_allocator&lt;pair&lt;const Key,T&gt;&gt;&gt;;

  template &lt;class Key, class T, class Compare = less&lt;Key&gt;&gt;
  using multimap = std::multimap&lt;Key, T, Compare,
                                 polymorphic_allocator&lt;pair&lt;const Key,T&gt;&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.set.synop">
    

    <section>
      <header><span class="section-number">8.11.7</span> <h1 data-bookmark-label="8.11.7 Header <experimental/set> synopsis">Header &lt;experimental/set&gt; synopsis</h1> <span style="float:right"><a href="#header.set.synop">[header.set.synop]</a></span></header>
      
      
<pre><code>#include &lt;set&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class Key, class Compare = less&lt;Key&gt;&gt;
  using set = std::set&lt;Key, Compare,
                       polymorphic_allocator&lt;Key&gt;&gt;;

  template &lt;class Key, class Compare = less&lt;Key&gt;&gt;
  using multiset = std::multiset&lt;Key, Compare,
                                 polymorphic_allocator&lt;Key&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.unordered_map.synop">
    

    <section>
      <header><span class="section-number">8.11.8</span> <h1 data-bookmark-label="8.11.8 Header <experimental/unordered_map> synopsis">Header &lt;experimental/unordered_map&gt; synopsis</h1> <span style="float:right"><a href="#header.unordered_map.synop">[header.unordered_map.synop]</a></span></header>
      
      
<pre><code>#include &lt;unordered_map&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class Key, class T,
            class Hash = hash&lt;Key&gt;,
            class Pred = equal_to&lt;Key&gt;&gt;
  using unordered_map =
    std::unordered_map&lt;Key, T, Hash, Pred,
                       polymorphic_allocator&lt;pair&lt;const Key,T&gt;&gt;&gt;;

  template &lt;class Key, class T,
            class Hash = hash&lt;Key&gt;,
            class Pred = equal_to&lt;Key&gt;&gt;
  using unordered_multimap =
    std::unordered_multimap&lt;Key, T, Hash, Pred,
                            polymorphic_allocator&lt;pair&lt;const Key,T&gt;&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.unordered_set.synop">
    

    <section>
      <header><span class="section-number">8.11.9</span> <h1 data-bookmark-label="8.11.9 Header <experimental/unordered_set> synopsis">Header &lt;experimental/unordered_set&gt; synopsis</h1> <span style="float:right"><a href="#header.unordered_set.synop">[header.unordered_set.synop]</a></span></header>
      
      
<pre><code>#include &lt;unordered_set&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class Key,
            class Hash = hash&lt;Key&gt;,
            class Pred = equal_to&lt;Key&gt;&gt;
  using unordered_set = std::unordered_set&lt;Key, Hash, Pred,
                                           polymorphic_allocator&lt;Key&gt;&gt;;

  template &lt;class Key,
            class Hash = hash&lt;Key&gt;,
            class Pred = equal_to&lt;Key&gt;&gt;
  using unordered_multiset =
    std::unordered_multiset&lt;Key, Hash, Pred,
                            polymorphic_allocator&lt;Key&gt;&gt;;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>

    <cxx-section id="header.regex.synop">
    

    <section>
      <header><span class="section-number">8.11.10</span> <h1 data-bookmark-label="8.11.10 Header <experimental/regex> synopsis">Header &lt;experimental/regex&gt; synopsis</h1> <span style="float:right"><a href="#header.regex.synop">[header.regex.synop]</a></span></header>
      
      
<pre><code>#include &lt;regex&gt;
#include &lt;experimental/string&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  template &lt;class BidirectionalIterator&gt;
  using match_results =
    std::match_results&lt;BidirectionalIterator,
                       polymorphic_allocator&lt;sub_match&lt;BidirectionalIterator&gt;&gt;&gt;;

  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;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>
    
    </section>
  </cxx-section>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="futures">
    

    <section>
      <header><span class="section-number">9</span> <h1 data-bookmark-label="9 Futures">Futures</h1> <span style="float:right"><a href="#futures">[futures]</a></span></header>
      
  

  <cxx-section id="header.future.synop">
    

    <section>
      <header><span class="section-number">9.1</span> <h1 data-bookmark-label="9.1 Header <experimental/future> synopsis">Header &lt;experimental/future&gt; synopsis</h1> <span style="float:right"><a href="#header.future.synop">[header.future.synop]</a></span></header>
      
    

    <cxx-ednote>
    
    <aside><strong>Editor's note:</strong> 
      An additional editorial fix is applied in the declaration of <code>swap</code> for <code>packaged_task</code>
    </aside>
  </cxx-ednote>

    <pre><code>#include &lt;future&gt;

namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    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&gt; class packaged_task; // undefined
    template &lt;class R, class... ArgTypes&gt;
    class packaged_task&lt;R(ArgTypes...)&gt;;

    template &lt;class R, class... ArgTypes&gt;
    void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp;, packaged_task&lt;R(ArgTypes...)&gt;&amp;) noexcept;

  } // namespace fundamentals_v1
  } // namespace experimental

  template &lt;class R, class Alloc&gt;
  struct uses_allocator&lt;experimental::promise&lt;R&gt;, Alloc&gt;;

  template &lt;class R, class Alloc&gt;
  struct uses_allocator&lt;experimental::packaged_task&lt;R&gt;, Alloc&gt;;

} // namespace std</code></pre>
  
    </section>
  </cxx-section>
  <cxx-section id="futures.promise">
    

    <section>
      <header><span class="section-number">9.2</span> <h1 data-bookmark-label="9.2 Class template promise">Class template <code>promise</code></h1> <span style="float:right"><a href="#futures.promise">[futures.promise]</a></span></header>
      
    

    <p para_num="1" id="futures.promise.1">
      The specification of all declarations within this sub-clause <cxx-ref to="futures.promise"><a title="futures.promise" href="#futures.promise">9.2</a></cxx-ref>
      and its sub-clauses are the same as the corresponding declarations,
      as specified in <cxx-ref in="cxx" to="futures.promise">C++14 <span title="futures.promise">§30.6.5</span></cxx-ref>,
      unless explicitly specified otherwise.
    </p>

    <pre><code>namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    template &lt;class R&gt;
    class promise {
    public:
      typedef erased_type allocator_type;

      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();

      promise&amp; operator=(promise&amp;&amp; rhs) noexcept;
      promise&amp; operator=(const promise&amp; rhs) = delete;
      void swap(promise&amp; other) noexcept;

      future&lt;R&gt; get_future();

      void set_value(<em>see below</em>);
      void set_exception(exception_ptr p);

      void set_value_at_thread_exit(const R&amp; r);
      void set_value_at_thread_exit(<em>see below</em>);
      void set_exception_at_thread_exit(exception_ptr p);

      pmr::memory_resource* get_memory_resource();
    };

    template &lt;class R&gt;
    void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y) noexcept;

  } // namespace fundamentals_v1
  } // namespace experimental

  template &lt;class R, class Alloc&gt;
  struct uses_allocator&lt;experimental::promise&lt;R&gt;, Alloc&gt;;

} // namespace std</code></pre>

    <p para_num="2" id="futures.promise.2">
      When a <code>promise</code> constructor that takes a first argument of type <code>allocator_arg_t</code> is invoked,
      the second argument is treated as a type-erased allocator (<cxx-ref to="memory.type.erased.allocator"><a title="memory.type.erased.allocator" href="#memory.type.erased.allocator">8.3</a></cxx-ref>).
    </p>
  
    </section>
  </cxx-section>

  <cxx-section id="futures.task">
    

    <section>
      <header><span class="section-number">9.3</span> <h1 data-bookmark-label="9.3 Class template packaged_task">Class template <code>packaged_task</code></h1> <span style="float:right"><a href="#futures.task">[futures.task]</a></span></header>
      
    

    <p para_num="1" id="futures.task.1">
      The specification of all declarations within this sub-clause <cxx-ref to="futures.task"><a title="futures.task" href="#futures.task">9.3</a></cxx-ref>
      and its sub-clauses are the same as the corresponding declarations,
      as specified in <cxx-ref in="cxx" to="futures.task">C++14 <span title="futures.task">§30.6.9</span></cxx-ref>,
      unless explicitly specified otherwise.
    </p>

    <pre><code>namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    template &lt;class R, class... ArgTypes&gt;
    class packaged_task&lt;R(ArgTypes...)&gt; {
    public:
      typedef erased_type allocator_type;

      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();

      packaged_task(const packaged_task&amp;) = delete;
      packaged_task&amp; operator=(const packaged_task&amp;) = delete;

      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;

      future&lt;R&gt; get_future();

      void operator()(ArgTypes... );
      void make_ready_at_thread_exit(ArgTypes...);

      void reset();

      pmr::memory_resource* get_memory_resource();
    };

    template &lt;class R, class... ArgTypes&gt;
    void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp;, packaged_task&lt;R(ArgTypes...)&gt;&amp;) noexcept;

  } // namespace fundamentals_v1
  } // namespace experimental

  template &lt;class R, class Alloc&gt;
  struct uses_allocator&lt;experimental::packaged_task&lt;R&gt;, Alloc&gt;;

} // namespace std</code></pre>

    <p para_num="2" id="futures.task.2">
      When a <code>packaged_task</code> constructor that takes a first argument of type <code>allocator_arg_t</code> is invoked,
      the second argument is treated as a type-erased allocator (<cxx-ref to="memory.type.erased.allocator"><a title="memory.type.erased.allocator" href="#memory.type.erased.allocator">8.3</a></cxx-ref>).
    </p>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>

<cxx-clause id="algorithms">
    

    <section>
      <header><span class="section-number">10</span> <h1 data-bookmark-label="10 Algorithms library">Algorithms library</h1> <span style="float:right"><a href="#algorithms">[algorithms]</a></span></header>
      
  

  <cxx-section id="header.algorithm.synop">
    

    <section>
      <header><span class="section-number">10.1</span> <h1 data-bookmark-label="10.1 Header <experimental/algorithm> synopsis">Header <code>&lt;experimental/algorithm&gt;</code> synopsis</h1> <span style="float:right"><a href="#header.algorithm.synop">[header.algorithm.synop]</a></span></header>
      
    

<pre><code>#include &lt;algorithm&gt;

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  template&lt;class ForwardIterator, class Searcher&gt;
  ForwardIterator search(ForwardIterator first, ForwardIterator last,
                         const Searcher&amp; searcher);

  template&lt;class PopulationIterator, class SampleIterator,
           class Distance, class UniformRandomNumberGenerator&gt;
  SampleIterator sample(PopulationIterator first, PopulationIterator last,
                        SampleIterator out, Distance n,
                        UniformRandomNumberGenerator&amp;&amp; g);

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std</code></pre>

  
    </section>
  </cxx-section>

  <cxx-section id="alg.search">
    

    <section>
      <header><span class="section-number">10.2</span> <h1 data-bookmark-label="10.2 Search">Search</h1> <span style="float:right"><a href="#alg.search">[alg.search]</a></span></header>
      
    

    <cxx-function para_num="1" id="alg.search.1">
    
    <pre><code><cxx-signature>template&lt;class ForwardIterator, class Searcher&gt;
ForwardIterator search(ForwardIterator first, ForwardIterator last,
                       const Searcher&amp; searcher);</cxx-signature></code></pre>

    <dl>
      
      

      <cxx-effects para_num="2" id="alg.search.2">
    
    <dt>Effects:</dt><dd>Equivalent to <code>return searcher(first, last)</code>.</dd>
  </cxx-effects>
      <cxx-remarks para_num="3" id="alg.search.3">
    
    <dt>Remarks:</dt><dd><code>Searcher</code> need not meet the <code>CopyConstructible</code> requirements.</dd>
  </cxx-remarks>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

  <cxx-section id="alg.random.sample">
    

    <section>
      <header><span class="section-number">10.3</span> <h1 data-bookmark-label="10.3 Shufﬂing and sampling">Shufﬂing and sampling</h1> <span style="float:right"><a href="#alg.random.sample">[alg.random.sample]</a></span></header>
      
    

    <cxx-function para_num="1" id="alg.random.sample.1">
    
    <pre><code><cxx-signature class="formatted">template&lt;class PopulationIterator, class SampleIterator,
         class Distance, class UniformRandomNumberGenerator&gt;
SampleIterator sample(PopulationIterator first, PopulationIterator last,
                      SampleIterator out, Distance n,
                      UniformRandomNumberGenerator&amp;&amp; g);</cxx-signature></code></pre>

    <dl>
      
      


      <cxx-requires para_num="2" id="alg.random.sample.2">
    
    <dt>Requires:</dt><dd>
        <ul>
          <li><code>PopulationIterator</code> shall meet the requirements of an <code>InputIterator</code> type.</li>
          <li><code>SampleIterator</code> shall meet the requirements of an <code>OutputIterator</code> type.</li>
          <li><code>SampleIterator</code> shall meet the additional requirements of a <code>RandomAccessIterator</code> type
          unless <code>PopulationIterator</code> meets the additional requirements of a <code>ForwardIterator</code> type.</li>
          <li><code>PopulationIterator</code>'s value type shall be writable to <code>out</code>.</li>
          <li><code>Distance</code> shall be an integer type.</li>
          <li><code>UniformRandomNumberGenerator</code> shall meet the requirements of a uniform random number generator type (<cxx-ref in="cxx" to="rand.req.urng">C++14 <span title="rand.req.urng">§26.5.1.3</span></cxx-ref>)
          whose return type is convertible to <code>Distance</code>.</li>
          <li><code>out</code> shall not be in the range <cxx-range begin="first" end="last">[<code>first</code>, <code>last</code>)</cxx-range>.</li>
        </ul>
      </dd>
  </cxx-requires>
      <cxx-effects para_num="3" id="alg.random.sample.3">
    
    <dt>Effects:</dt><dd>Copies <code>min(last−first, n)</code> elements (the <dfn>sample</dfn>)
      from <cxx-range begin="first" end="last">[<code>first</code>, <code>last</code>)</cxx-range> (the <dfn>population</dfn>) to <code>out</code>
      such that each possible sample has equal probability of appearance.
      <cxx-note><span class="nowrap">[ <em>Note:</em></span>
    Algorithms that obtain such effects include <cxx-term><i>selection sampling</i></cxx-term> and <cxx-term><i>reservoir sampling</i></cxx-term>.
    <span class="nowrap">— <em>end note</em> ]</span>
  </cxx-note></dd>
  </cxx-effects>
      <cxx-returns para_num="4" id="alg.random.sample.4">
    
    <dt>Returns:</dt><dd>The end of the resulting sample range.</dd>
  </cxx-returns>
      <cxx-complexity para_num="5" id="alg.random.sample.5">
    
    <dt>Complexity:</dt><dd>O(<code>n</code>).</dd>
  </cxx-complexity>
      <cxx-remarks para_num="6" id="alg.random.sample.6">
    
    <dt>Remarks:</dt><dd>
        <ul>
          <li>Stable if and only if <code>PopulationIterator</code> meets the requirements of a <code>ForwardIterator</code> type.</li>
          <li>To the extent that the implementation of this function makes use of random numbers, the object <code>g</code> shall serve as the implementation’s source of randomness.</li>
        </ul>
      </dd>
  </cxx-remarks>
    
    </dl>
  </cxx-function>
  
    </section>
  </cxx-section>

    </section>
  </cxx-clause>





</body></html>
