<!DOCTYPE html>

<html lang="en">

<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <meta name="mobile-web-app-capable" content="yes">
    <title>
        `inplace_vector`
    </title>

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha256-916EbMg70RQy9LHiGkXzG8hSg9EdNy97GazNG/aiY1w=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" integrity="sha256-eZrrJcwDc/3uDhsdt61sL2oOBY362qM3lon1gyExkL0=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/ionicons/2.0.1/css/ionicons.min.css" integrity="sha256-3iu9jgsy9TpTwXKb7bNQzqWekRX7pPK+2OLj3R922fo=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/octicons/3.5.0/octicons.min.css" integrity="sha256-QiWfLIsCT02Sdwkogf6YMiQlj4NE84MKkzEMkZnMGdg=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.5.1/themes/prism.min.css" integrity="sha256-vtR0hSWRc3Tb26iuN2oZHt3KRUomwTufNIf5/4oeCyg=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/css/basic/emojify.min.css" integrity="sha256-UOrvMOsSDSrW6szVLe8ZDZezBxh5IoIfgTwdNDgTjiU=" crossorigin="anonymous" />
    <style>
        @import url(https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,500,500i|Source+Code+Pro:300,400,500|Source+Sans+Pro:300,300i,400,400i,600,600i|Source+Serif+Pro&subset=latin-ext);.hljs{background:#fff;color:#333;display:block;overflow-x:auto;padding:.5em}.hljs-comment,.hljs-meta{color:#969896}.hljs-emphasis,.hljs-quote,.hljs-string,.hljs-strong,.hljs-template-variable,.hljs-variable{color:#df5000}.hljs-keyword,.hljs-selector-tag,.hljs-type{color:#a71d5d}.hljs-attribute,.hljs-bullet,.hljs-literal,.hljs-number,.hljs-symbol{color:#0086b3}.hljs-built_in,.hljs-builtin-name{color:#005cc5}.hljs-name,.hljs-section{color:#63a35c}.hljs-tag{color:#333}.hljs-attr,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-selector-pseudo,.hljs-title{color:#795da3}.hljs-addition{background-color:#eaffea;color:#55a532}.hljs-deletion{background-color:#ffecec;color:#bd2c00}.hljs-link{text-decoration:underline}.markdown-body{word-wrap:break-word;font-size:16px;line-height:1.5}.markdown-body:after,.markdown-body:before{content:"";display:table}.markdown-body:after{clear:both}.markdown-body>:first-child{margin-top:0!important}.markdown-body>:last-child{margin-bottom:0!important}.markdown-body a:not([href]){color:inherit;text-decoration:none}.markdown-body .absent{color:#c00}.markdown-body .anchor{float:left;line-height:1;margin-left:-20px;padding-right:4px}.markdown-body .anchor:focus{outline:none}.markdown-body blockquote,.markdown-body dl,.markdown-body ol,.markdown-body p,.markdown-body pre,.markdown-body table,.markdown-body ul{margin-bottom:16px;margin-top:0}.markdown-body hr{background-color:#e7e7e7;border:0;height:.25em;margin:24px 0;padding:0}.markdown-body blockquote{border-left:.25em solid #ddd;color:#777;font-size:16px;padding:0 1em}.markdown-body blockquote>:first-child{margin-top:0}.markdown-body blockquote>:last-child{margin-bottom:0}.markdown-body kbd,.popover kbd{background-color:#fcfcfc;border:1px solid;border-color:#ccc #ccc #bbb;border-radius:3px;box-shadow:inset 0 -1px 0 #bbb;color:#555;display:inline-block;font-size:11px;line-height:10px;padding:3px 5px;vertical-align:middle}.markdown-body .loweralpha{list-style-type:lower-alpha}.markdown-body h1,.markdown-body h2,.markdown-body h3,.markdown-body h4,.markdown-body h5,.markdown-body h6{font-weight:600;line-height:1.25;margin-bottom:16px;margin-top:24px}.markdown-body h1 .octicon-link,.markdown-body h2 .octicon-link,.markdown-body h3 .octicon-link,.markdown-body h4 .octicon-link,.markdown-body h5 .octicon-link,.markdown-body h6 .octicon-link{color:#000;vertical-align:middle;visibility:hidden}.markdown-body h1:hover .anchor,.markdown-body h2:hover .anchor,.markdown-body h3:hover .anchor,.markdown-body h4:hover .anchor,.markdown-body h5:hover .anchor,.markdown-body h6:hover .anchor{text-decoration:none}.markdown-body h1:hover .anchor .octicon-link,.markdown-body h2:hover .anchor .octicon-link,.markdown-body h3:hover .anchor .octicon-link,.markdown-body h4:hover .anchor .octicon-link,.markdown-body h5:hover .anchor .octicon-link,.markdown-body h6:hover .anchor .octicon-link{visibility:visible}.markdown-body h1 code,.markdown-body h1 tt,.markdown-body h2 code,.markdown-body h2 tt,.markdown-body h3 code,.markdown-body h3 tt,.markdown-body h4 code,.markdown-body h4 tt,.markdown-body h5 code,.markdown-body h5 tt,.markdown-body h6 code,.markdown-body h6 tt{font-size:inherit}.markdown-body h1{font-size:2em}.markdown-body h1,.markdown-body h2{border-bottom:1px solid #eee;padding-bottom:.3em}.markdown-body h2{font-size:1.5em}.markdown-body h3{font-size:1.25em}.markdown-body h4{font-size:1em}.markdown-body h5{font-size:.875em}.markdown-body h6{color:#777;font-size:.85em}.markdown-body ol,.markdown-body ul{padding-left:2em}.markdown-body ol.no-list,.markdown-body ul.no-list{list-style-type:none;padding:0}.markdown-body ol ol,.markdown-body ol ul,.markdown-body ul ol,.markdown-body ul ul{margin-bottom:0;margin-top:0}.markdown-body li>p{margin-top:16px}.markdown-body li+li{padding-top:.25em}.markdown-body dl{padding:0}.markdown-body dl dt{font-size:1em;font-style:italic;font-weight:700;margin-top:16px;padding:0}.markdown-body dl dd{margin-bottom:16px;padding:0 16px}.markdown-body table{display:block;overflow:auto;width:100%;word-break:normal;word-break:keep-all}.markdown-body table th{font-weight:700}.markdown-body table td,.markdown-body table th{border:1px solid #ddd;padding:6px 13px}.markdown-body table tr{background-color:#fff;border-top:1px solid #ccc}.markdown-body table tr:nth-child(2n){background-color:#f8f8f8}.markdown-body img{background-color:#fff;box-sizing:initial;max-width:100%}.markdown-body img[align=right]{padding-left:20px}.markdown-body img[align=left]{padding-right:20px}.markdown-body .emoji{background-color:initial;max-width:none;vertical-align:text-top}.markdown-body span.frame{display:block;overflow:hidden}.markdown-body span.frame>span{border:1px solid #ddd;display:block;float:left;margin:13px 0 0;overflow:hidden;padding:7px;width:auto}.markdown-body span.frame span img{display:block;float:left}.markdown-body span.frame span span{clear:both;color:#333;display:block;padding:5px 0 0}.markdown-body span.align-center{clear:both;display:block;overflow:hidden}.markdown-body span.align-center>span{display:block;margin:13px auto 0;overflow:hidden;text-align:center}.markdown-body span.align-center span img{margin:0 auto;text-align:center}.markdown-body span.align-right{clear:both;display:block;overflow:hidden}.markdown-body span.align-right>span{display:block;margin:13px 0 0;overflow:hidden;text-align:right}.markdown-body span.align-right span img{margin:0;text-align:right}.markdown-body span.float-left{display:block;float:left;margin-right:13px;overflow:hidden}.markdown-body span.float-left span{margin:13px 0 0}.markdown-body span.float-right{display:block;float:right;margin-left:13px;overflow:hidden}.markdown-body span.float-right>span{display:block;margin:13px auto 0;overflow:hidden;text-align:right}.markdown-body code,.markdown-body tt{background-color:#0000000a;border-radius:3px;font-size:85%;margin:0;padding:.2em 0}.markdown-body code:after,.markdown-body code:before,.markdown-body tt:after,.markdown-body tt:before{content:"\00a0";letter-spacing:-.2em}.markdown-body code br,.markdown-body tt br{display:none}.markdown-body del code{text-decoration:inherit}.markdown-body pre{word-wrap:normal}.markdown-body pre>code{background:#0000;border:0;font-size:100%;margin:0;padding:0;white-space:pre;word-break:normal}.markdown-body .highlight{margin-bottom:16px}.markdown-body .highlight pre{margin-bottom:0;word-break:normal}.markdown-body .highlight pre,.markdown-body pre{border-radius:3px;font-size:85%;line-height:1.45;overflow:auto}.markdown-body:not(.next-editor) pre{background-color:#f7f7f7;padding:16px}.markdown-body pre code,.markdown-body pre tt{word-wrap:normal;background-color:initial;border:0;display:inline;line-height:inherit;margin:0;max-width:auto;overflow:visible;padding:0}.markdown-body pre code:after,.markdown-body pre code:before,.markdown-body pre tt:after,.markdown-body pre tt:before{content:normal}.markdown-body .csv-data td,.markdown-body .csv-data th{font-size:12px;line-height:1;overflow:hidden;padding:5px;text-align:left;white-space:nowrap}.markdown-body .csv-data .blob-line-num{background:#fff;border:0;padding:10px 8px 9px;text-align:right}.markdown-body .csv-data tr{border-top:0}.markdown-body .csv-data th{background:#f8f8f8;border-top:0;font-weight:700}.news .alert .markdown-body blockquote{border:0;padding:0 0 0 40px}.activity-tab .news .alert .commits,.activity-tab .news .markdown-body blockquote{padding-left:0}.task-list-item{list-style-type:none}.task-list-item label{font-weight:400}.task-list-item.enabled label{cursor:pointer}.task-list-item+.task-list-item{margin-top:3px}.task-list-item-checkbox{cursor:default!important;float:left;margin:.31em 0 .2em -1.3em!important;vertical-align:middle}.markdown-alert{border-left-style:solid;border-left-width:4px;color:inherit;margin-bottom:16px;padding:8px 16px}.markdown-alert .markdown-alert-title{align-items:center;display:flex;font-weight:500;line-height:1;white-space:break-spaces}.markdown-body .markdown-alert>*{margin-bottom:0;margin-top:16px}.markdown-body .markdown-alert .selection-popover,.markdown-body .markdown-alert>:first-child{margin-top:0}.markdown-alert.markdown-alert-note{border-left-color:#0969da}.markdown-alert.markdown-alert-note .markdown-alert-title{fill:currentColor;color:#0969da}.markdown-alert.markdown-alert-tip{border-left-color:#1a7f37}.markdown-alert.markdown-alert-tip .markdown-alert-title{fill:currentColor;color:#1a7f37}.markdown-alert.markdown-alert-important{border-left-color:#8250df}.markdown-alert.markdown-alert-important .markdown-alert-title{fill:currentColor;color:#8250df}.markdown-alert.markdown-alert-warning{border-left-color:#9a6700}.markdown-alert.markdown-alert-warning .markdown-alert-title{fill:currentColor;color:#9a6700}.markdown-alert.markdown-alert-caution{border-left-color:#d1242f}.markdown-alert.markdown-alert-caution .markdown-alert-title{fill:currentColor;color:#d1242f}.markdown-body{max-width:758px;overflow:visible!important;padding-bottom:40px;padding-top:40px;position:relative}.markdown-body.next-editor{overflow-x:hidden!important}.markdown-body .emoji{vertical-align:top}.markdown-body pre{border:inherit!important}.markdown-body code{color:inherit!important}.markdown-body pre code .wrapper{display:-moz-inline-flex;display:-ms-inline-flex;display:-o-inline-flex;display:inline-flex}.markdown-body pre code .gutter{float:left;overflow:hidden;-webkit-user-select:none;user-select:none}.markdown-body pre code .gutter.linenumber{border-right:3px solid #6ce26c!important;box-sizing:initial;color:#afafaf!important;cursor:default;display:inline-block;min-width:20px;padding:0 8px 0 0;position:relative;text-align:right;z-index:4}.markdown-body pre code .gutter.linenumber>span:before{content:attr(data-linenumber)}.markdown-body pre code .code{float:left;margin:0 0 0 16px}.markdown-body .gist .line-numbers{border-bottom:none;border-left:none;border-top:none}.markdown-body .gist .line-data{border:none}.markdown-body .gist table{border-collapse:inherit!important;border-spacing:0}.markdown-body code[data-gist-id]{background:none;padding:0}.markdown-body code[data-gist-id]:after,.markdown-body code[data-gist-id]:before{content:""}.markdown-body code[data-gist-id] .blob-num{border:unset}.markdown-body code[data-gist-id] table{margin-bottom:unset;overflow:unset}.markdown-body code[data-gist-id] table tr{background:unset}.markdown-body[dir=rtl] pre{direction:ltr}.markdown-body[dir=rtl] code{direction:ltr;unicode-bidi:embed}.markdown-body .alert{display:flex;flex-direction:column;gap:16px}.markdown-body .alert>*{margin:0}.markdown-body pre.abc,.markdown-body pre.flow-chart,.markdown-body pre.graphviz,.markdown-body pre.mermaid,.markdown-body pre.sequence-diagram,.markdown-body pre.vega{background-color:inherit;border-radius:0;overflow:visible;text-align:center;white-space:inherit}.markdown-body pre.abc>code,.markdown-body pre.flow-chart>code,.markdown-body pre.graphviz>code,.markdown-body pre.mermaid>code,.markdown-body pre.sequence-diagram>code,.markdown-body pre.vega>code{text-align:left}.markdown-body pre.abc>svg,.markdown-body pre.flow-chart>svg,.markdown-body pre.graphviz>svg,.markdown-body pre.mermaid>svg,.markdown-body pre.sequence-diagram>svg,.markdown-body pre.vega>svg{height:100%;max-width:100%}.markdown-body pre>code.wrap{word-wrap:break-word;white-space:pre-wrap;white-space:-moz-pre-wrap;white-space:-pre-wrap;white-space:-o-pre-wrap}.markdown-body pre.pseudocode{white-space-collapse:collapse}.markdown-body summary{display:list-item}.markdown-body summary:focus{outline:none}.markdown-body details summary{cursor:pointer}.markdown-body details:not([open])>:not(summary){display:none}.markdown-body figure{margin:1em 40px}.markdown-body .mark,.markdown-body mark{background-color:#fff1a7}.vimeo,.youtube{background-color:#000;background-position:50%;background-repeat:no-repeat;background-size:contain;cursor:pointer;display:table;overflow:hidden;text-align:center}.vimeo,.youtube{position:relative;width:100%}.youtube{padding-bottom:56.25%}.vimeo img{object-fit:contain;width:100%;z-index:0}.youtube img{object-fit:cover;z-index:0}.vimeo iframe,.youtube iframe,.youtube img{height:100%;left:0;position:absolute;top:0;width:100%}.vimeo iframe,.youtube iframe{vertical-align:middle;z-index:1}.vimeo .icon,.youtube .icon{color:#fff;height:auto;left:50%;opacity:.3;position:absolute;top:50%;transform:translate(-50%,-50%);transition:opacity .2s;width:auto;z-index:0}.vimeo:hover .icon,.youtube:hover .icon{opacity:.6;transition:opacity .2s}.slideshare .inner,.speakerdeck .inner{position:relative;width:100%}.slideshare .inner iframe,.speakerdeck .inner iframe{bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%}.figma{display:table;padding-bottom:56.25%;position:relative;width:100%}.figma iframe{border:1px solid #eee;bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%}.markmap-container{height:300px}.markmap-container>svg{height:100%;width:100%}.MJX_Assistive_MathML{display:none}#MathJax_Message{z-index:1000!important}.ui-infobar{color:#777;margin:25px auto -25px;max-width:760px;position:relative;z-index:2}.toc .invisable-node{list-style-type:none}.ui-toc{bottom:20px;position:fixed;z-index:998}.ui-toc.both-mode{margin-left:8px}.ui-toc.both-mode .ui-toc-label{border-bottom-left-radius:0;border-top-left-radius:0;height:40px;padding:10px 4px}.ui-toc-label{background-color:#e6e6e6;border:none;color:#868686;transition:opacity .2s}.ui-toc .open .ui-toc-label{color:#fff;opacity:1;transition:opacity .2s}.ui-toc-label:focus{background-color:#ccc;color:#000;opacity:.3}.ui-toc-label:hover{background-color:#ccc;opacity:1;transition:opacity .2s}.ui-toc-dropdown{margin-bottom:20px;margin-top:20px;max-height:70vh;max-width:45vw;overflow:auto;padding-left:10px;padding-right:10px;text-align:inherit;width:25vw}.ui-toc-dropdown>.toc{max-height:calc(70vh - 100px);overflow:auto}.ui-toc-dropdown[dir=rtl] .nav{letter-spacing:.0029em;padding-right:0}.ui-toc-dropdown a{overflow:hidden;text-overflow:ellipsis;white-space:pre}.ui-toc-dropdown .nav>li>a{color:#767676;display:block;font-size:13px;font-weight:500;padding:4px 20px}.ui-toc-dropdown .nav>li:first-child:last-child>ul,.ui-toc-dropdown .toc.expand ul{display:block}.ui-toc-dropdown .nav>li>a:focus,.ui-toc-dropdown .nav>li>a:hover{background-color:initial;border-left:1px solid #000;color:#000;padding-left:19px;text-decoration:none}.ui-toc-dropdown[dir=rtl] .nav>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav>li>a:hover{border-left:none;border-right:1px solid #000;padding-right:19px}.ui-toc-dropdown .nav>.active:focus>a,.ui-toc-dropdown .nav>.active:hover>a,.ui-toc-dropdown .nav>.active>a{background-color:initial;border-left:2px solid #000;color:#000;font-weight:700;padding-left:18px}.ui-toc-dropdown[dir=rtl] .nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav>.active>a{border-left:none;border-right:2px solid #000;padding-right:18px}.ui-toc-dropdown .nav .nav{display:none;padding-bottom:10px}.ui-toc-dropdown .nav>.active>ul{display:block}.ui-toc-dropdown .nav .nav>li>a{font-size:12px;font-weight:400;padding-bottom:1px;padding-left:30px;padding-top:1px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>a{padding-right:30px}.ui-toc-dropdown .nav .nav>li>ul>li>a{font-size:12px;font-weight:400;padding-bottom:1px;padding-left:40px;padding-top:1px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a{padding-right:40px}.ui-toc-dropdown .nav .nav>li>a:focus,.ui-toc-dropdown .nav .nav>li>a:hover{padding-left:29px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav .nav>li>a:hover{padding-right:29px}.ui-toc-dropdown .nav .nav>li>ul>li>a:focus,.ui-toc-dropdown .nav .nav>li>ul>li>a:hover{padding-left:39px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a:hover{padding-right:39px}.ui-toc-dropdown .nav .nav>.active:focus>a,.ui-toc-dropdown .nav .nav>.active:hover>a,.ui-toc-dropdown .nav .nav>.active>a{font-weight:500;padding-left:28px}.ui-toc-dropdown[dir=rtl] .nav .nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>a{padding-right:28px}.ui-toc-dropdown .nav .nav>.active>.nav>.active:focus>a,.ui-toc-dropdown .nav .nav>.active>.nav>.active:hover>a,.ui-toc-dropdown .nav .nav>.active>.nav>.active>a{font-weight:500;padding-left:38px}.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active>a{padding-right:38px}.markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang^=ja] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang=zh-tw] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang=zh-cn] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html .markdown-body[lang^=ja]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html .markdown-body[lang=zh-tw]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html .markdown-body[lang=zh-cn]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang^=ja] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Meiryo UI,MS PGothic,ＭＳ Ｐゴシック,sans-serif}html[lang=zh-tw] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Microsoft JhengHei UI,微軟正黑UI,sans-serif}html[lang=zh-cn] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Microsoft YaHei UI,微软雅黑UI,sans-serif}html .ui-toc-dropdown[lang^=ja]{font-family:Source Sans Pro,Helvetica,Arial,Meiryo UI,MS PGothic,ＭＳ Ｐゴシック,sans-serif}html .ui-toc-dropdown[lang=zh-tw]{font-family:Source Sans Pro,Helvetica,Arial,Microsoft JhengHei UI,微軟正黑UI,sans-serif}html .ui-toc-dropdown[lang=zh-cn]{font-family:Source Sans Pro,Helvetica,Arial,Microsoft YaHei UI,微软雅黑UI,sans-serif}.ui-affix-toc{max-height:70vh;max-width:15vw;overflow:auto;position:fixed;top:0}.back-to-top,.expand-toggle,.go-to-bottom{color:#999;display:block;font-size:12px;font-weight:500;margin-left:10px;margin-top:10px;padding:4px 10px}.back-to-top:focus,.back-to-top:hover,.expand-toggle:focus,.expand-toggle:hover,.go-to-bottom:focus,.go-to-bottom:hover{color:#563d7c;text-decoration:none}.back-to-top,.go-to-bottom{margin-top:0}.ui-user-icon{background-position:50%;background-repeat:no-repeat;background-size:cover;border-radius:50%;display:block;height:20px;margin-bottom:2px;margin-right:5px;margin-top:2px;width:20px}.ui-user-icon.small{display:inline-block;height:18px;margin:0 0 .2em;vertical-align:middle;width:18px}.ui-infobar>small>span{line-height:22px}.ui-infobar>small .dropdown{display:inline-block}.ui-infobar>small .dropdown a:focus,.ui-infobar>small .dropdown a:hover{text-decoration:none}.ui-more-info{color:#888;cursor:pointer;vertical-align:middle}.ui-more-info .fa{font-size:16px}.ui-connectedGithub,.ui-published-note{color:#888}.ui-connectedGithub{line-height:23px;white-space:nowrap}.ui-connectedGithub a.file-path{color:#888;padding-left:22px;text-decoration:none}.ui-connectedGithub a.file-path:active,.ui-connectedGithub a.file-path:hover{color:#888;text-decoration:underline}.ui-connectedGithub .fa{font-size:20px}.ui-published-note .fa{font-size:20px;vertical-align:top}.unselectable{-webkit-user-select:none;-o-user-select:none;user-select:none}.selectable{-webkit-user-select:text;-o-user-select:text;user-select:text}.inline-spoiler-section{cursor:pointer}.inline-spoiler-section .spoiler-text{background-color:#333;border-radius:2px}.inline-spoiler-section .spoiler-text>*{opacity:0}.inline-spoiler-section .spoiler-img{filter:blur(10px)}.inline-spoiler-section.raw{background-color:#333;border-radius:2px}.inline-spoiler-section.raw>*{opacity:0}.inline-spoiler-section.unveil{cursor:auto}.inline-spoiler-section.unveil .spoiler-text{background-color:#3333331a}.inline-spoiler-section.unveil .spoiler-text>*{opacity:1}.inline-spoiler-section.unveil .spoiler-img{filter:none}@media print{blockquote,div,img,pre,table{page-break-inside:avoid!important}a[href]:after{font-size:12px!important}}.markdown-body.slides{color:#222;position:relative;z-index:1}.markdown-body.slides:before{background-color:currentColor;bottom:0;box-shadow:0 0 0 50vw;content:"";display:block;left:0;position:absolute;right:0;top:0;z-index:-1}.markdown-body.slides section[data-markdown]{background-color:#fff;margin-bottom:1.5em;position:relative;text-align:center}.markdown-body.slides section[data-markdown] code{text-align:left}.markdown-body.slides section[data-markdown]:before{content:"";display:block;padding-bottom:56.23%}.markdown-body.slides section[data-markdown]>div:first-child{left:1em;max-height:100%;overflow:hidden;position:absolute;right:1em;top:50%;transform:translateY(-50%)}.markdown-body.slides section[data-markdown]>ul{display:inline-block}.markdown-body.slides>section>section+section:after{border:3px solid #777;content:"";height:1.5em;position:absolute;right:1em;top:-1.5em}.site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,sans-serif}html[lang^=ja] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif}html[lang=zh-tw] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}body{font-smoothing:subpixel-antialiased!important;-webkit-font-smoothing:subpixel-antialiased!important;-moz-osx-font-smoothing:auto!important;-webkit-overflow-scrolling:touch;font-family:Source Sans Pro,Helvetica,Arial,sans-serif;letter-spacing:.025em}html[lang^=ja] body{font-family:Source Sans Pro,Helvetica,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif}html[lang=zh-tw] body{font-family:Source Sans Pro,Helvetica,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] body{font-family:Source Sans Pro,Helvetica,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}abbr[data-original-title],abbr[title]{cursor:help}body.modal-open{overflow-y:auto;padding-right:0!important}svg{text-shadow:none}
    </style>
    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    	<script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv.min.js" integrity="sha256-3Jy/GbSLrg0o9y5Z5n1uw0qxZECH7C6OQpVBgNFYa0g=" crossorigin="anonymous"></script>
    	<script src="https://cdnjs.cloudflare.com/ajax/libs/respond.js/1.4.2/respond.min.js" integrity="sha256-g6iAfvZp+nDQ2TdTR/VVKJf3bGro4ub5fvWSWVRi2NE=" crossorigin="anonymous"></script>
		<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.5.9/es5-shim.min.js" integrity="sha256-8E4Is26QH0bD52WoQpcB+R/tcWQtpzlCojrybUd7Mxo=" crossorigin="anonymous"></script>
    <![endif]-->
</head>

<body>
    <div id="doc" class="markdown-body container-fluid comment-enabled" data-hard-breaks="true" style=""><h1 id="inplace_vector" data-id="inplace_vector"><a class="anchor hidden-xs" href="#inplace_vector" title="inplace_vector"><span class="octicon octicon-link"></span></a><code>inplace_vector</code></h1><blockquote>
<p><span>A dynamically-resizable vector with fixed capacity and embedded storage</span></p>
</blockquote><p><strong><span>Document number</span></strong><span>: P0843R12.</span><br>
<strong><span>Date</span></strong><span>: 2024-05-20.</span><br>
<strong><span>Authors</span></strong><span>: Gonzalo Brito Gadeschi, Timur Doumler &lt;papers _at_ timur.audio&gt;, Nevin Liber, David Sankel &lt;dsankel _at_ </span><a href="http://adobe.com" target="_blank" rel="noopener"><span>adobe.com</span></a><span>&gt;.</span><br>
<strong><span>Reply to</span></strong><span>: Gonzalo Brito Gadeschi &lt;gonzalob _at_ </span><a href="http://nvidia.com" target="_blank" rel="noopener"><span>nvidia.com</span></a><span>&gt;.</span><br>
<strong><span>Audience</span></strong><span>: LWG.</span></p><style>
bdo {
    color:green;
    background-color:yellow;
    text-decoration:underline;
}
ins {
    color:green;
    text-decoration:underline;
}
del {
    color:red;
    background-color:yellow;
    text-decoration:line-through;
}
bdi {
    color:black;
    background-color:lightblue;
    text-decoration:underline;
}
.markdown-body {
    max-width: 1200px;
    text-align: justify;
}
</style><p><big><span>Table of Contents</span></big></p><p><span class="toc"><ul>
<li><a href="#inplace_vector" title="inplace_vector">inplace_vector</a></li>
<li><a href="#Introduction" title="Introduction">Introduction</a></li>
<li><a href="#Motivation-and-Scope" title="Motivation and Scope">Motivation and Scope</a></li>
<li><a href="#Existing-practice" title="Existing practice">Existing practice</a></li>
<li><a href="#Design" title="Design">Design</a><ul>
<li><a href="#Standalone-or-a-special-case-another-type" title="Standalone or a special case another type?">Standalone or a special case another type?</a></li>
<li><a href="#Layout" title="Layout">Layout</a></li>
<li><a href="#Move-semantics" title="Move semantics">Move semantics</a></li>
<li><a href="#constexpr-support" title="constexpr support">constexpr support</a></li>
<li><a href="#Exception-Safety" title="Exception Safety">Exception Safety</a><ul>
<li><a href="#Exception-Safety-guarantees-of-Mutating-Operations" title="Exception Safety guarantees of Mutating Operations">Exception Safety guarantees of Mutating Operations</a></li>
<li><a href="#Exception-thrown-by-mutating-operations-exceeding-capacity" title="Exception thrown by mutating operations exceeding capacity">Exception thrown by mutating operations exceeding capacity</a></li>
</ul>
</li>
<li><a href="#Fallible-APIs" title="Fallible APIs">Fallible APIs</a></li>
<li><a href="#Fallible-Unchecked-APIs" title="Fallible Unchecked APIs">Fallible Unchecked APIs</a></li>
<li><a href="#Allocator-awareness" title="Allocator awareness">Allocator awareness</a></li>
<li><a href="#Iterator-invalidation" title="Iterator invalidation">Iterator invalidation</a></li>
<li><a href="#Freestanding" title="Freestanding">Freestanding</a></li>
<li><a href="#Same-or-Separate-header" title="Same or Separate header">Same or Separate header</a></li>
<li><a href="#Return-type-of-push_back" title="Return type of push_back">Return type of push_back</a></li>
<li><a href="#reserve-and-shrink_to_fit-APIs" title="reserve and shrink_to_fit APIs">reserve and shrink_to_fit APIs</a></li>
<li><a href="#Deduction-guides" title="Deduction guides">Deduction guides</a></li>
<li><a href="#Summary-of-semantic-differences-with-vector" title="Summary of semantic differences with vector">Summary of semantic differences with vector</a></li>
<li><a href="#Name" title="Name">Name</a></li>
</ul>
</li>
<li><a href="#Technical-specification" title="Technical specification">Technical specification</a><ul>
<li><a href="#libraryrequirementsorganizationheaders" title="[library.requirements.organization.headers]">[library.requirements.organization.headers]</a></li>
<li><a href="#iteratorrange-Range-access" title="[iterator.range] Range access">[iterator.range] Range access</a></li>
<li><a href="#containerallocreqmts" title="[container.alloc.reqmts]">[container.alloc.reqmts]</a></li>
<li><a href="#allocatorrequirementsgeneral" title="[allocator.requirements.general]">[allocator.requirements.general]</a></li>
<li><a href="#containersgeneral" title="[containers.general]">[containers.general]</a></li>
<li><a href="#containerreqmts-General-container-requirements" title="[container.reqmts] General container requirements">[container.reqmts] General container requirements</a></li>
<li><a href="#containerssequencesgeneral" title="[containers.sequences.general]">[containers.sequences.general]</a></li>
<li><a href="#containerrequirementssequencereqmts" title="[container.requirements.sequence.reqmts]">[container.requirements.sequence.reqmts]</a></li>
<li><a href="#containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis" title="[containers.sequences.inplace.vector.syn] Header <inplace_vector> synopsis">[containers.sequences.inplace.vector.syn] Header &lt;inplace_vector&gt; synopsis</a></li>
<li><a href="#containerssequencesinplacevector-Class-template-inplace_vector" title="[containers.sequences.inplace.vector] Class template inplace_vector">[containers.sequences.inplace.vector] Class template inplace_vector</a><ul>
<li><a href="#containerssequencesinplacevectoroverview-Overview" title="[containers.sequences.inplace.vector.overview] Overview">[containers.sequences.inplace.vector.overview] Overview</a></li>
<li><a href="#containerssequencesinplacevectorcons-Constructors" title="[containers.sequences.inplace.vector.cons] Constructors">[containers.sequences.inplace.vector.cons] Constructors</a></li>
<li><a href="#containerssequencesinplacevectorcapacity-Size-and-capacity" title="[containers.sequences.inplace.vector.capacity] Size and capacity">[containers.sequences.inplace.vector.capacity] Size and capacity</a></li>
<li><a href="#containerssequencesinplacevectordata-Data" title="[containers.sequences.inplace.vector.data] Data">[containers.sequences.inplace.vector.data] Data</a></li>
<li><a href="#containerssequencesinplacevectormodifiers-Modifiers" title="[containers.sequences.inplace.vector.modifiers] Modifiers">[containers.sequences.inplace.vector.modifiers] Modifiers</a></li>
<li><a href="#containerssequencesinplacevectorerasure-Erasure" title="[containers.sequences.inplace.vector.erasure] Erasure">[containers.sequences.inplace.vector.erasure] Erasure</a></li>
</ul>
</li>
<li><a href="#versionsyn" title="[version.syn]">[version.syn]</a></li>
<li><a href="#diffcpp23library-Compatibility" title="[diff.cpp23.library] Compatibility">[diff.cpp23.library] Compatibility</a></li>
</ul>
</li>
<li><a href="#Acknowledgments" title="Acknowledgments">Acknowledgments</a></li>
</ul>
</span></p><p><strong><big><span>Changelog</span></big></strong></p><ul>
<li><strong><span>Revision 12</span></strong>
<ul>
<li><span>Conditionally </span><code>constexpr</code><span> as per older revision.</span></li>
<li><span>Re-introduce </span><code>constexpr</code><span> discussion (dropped in R8).</span></li>
</ul>
</li>
<li><strong><span>Revision 11</span></strong>
<ul>
<li><span>Container </span><code>erase</code><span>/</span><code>erase_if</code><span> non-member functions made freestanding.</span></li>
<li><span>Require </span><code>is_nothrow_move_constructible_v&lt;T&gt;</code><span> for </span><code>operator=(inplace_vector&amp;&amp; other)</code><span>.</span></li>
<li><span>Remove </span><code>[[nodiscard]]</code><span> from </span><code>empty</code><span>.</span></li>
</ul>
</li>
<li><strong><span>Revision 10</span></strong>
<ul>
<li><span>Extend </span><code>constexpr</code><span> from "trivial" types to "literal" types.</span></li>
<li><span>Remove </span><code>unchecked_append_range</code><span>: adds very little value (one branch amortized over all inserted elements).</span></li>
<li><span>Update remarks of mutating elements to specify that if an exception occurs while inserting elements, the succesfully inserted elements are kept.</span></li>
<li><span>Discussion of execption safety guarantees for mutating operations and outcome from LEWG discussion.</span></li>
<li><span>Should not be allocator away.</span></li>
<li><span>Should throw </span><code>bad_alloc</code><span> on exceeding capacity.</span></li>
<li><span>Should be in a separate header.</span></li>
<li><span>Added fallible </span><code>append_range</code><span> APIs.</span></li>
<li><span>Move iterator erase methods from [vector.erasure] to [vector.modifiers].</span></li>
<li><span>Updated some EDITORIAL notes.</span></li>
<li><span>Fixed typo in [vector.modifiers], the </span><code>insert_range</code><span> method was incorrectly named </span><code>insert</code><span>.</span></li>
<li><span>Add accidentally missing </span><code>append_range</code><span> to [vector.modifiers].</span></li>
<li><span>Removed unnecessary </span><em><span>Complexity</span></em><span> clauses from </span><code>resize</code><span> methods.</span></li>
</ul>
</li>
<li><strong><span>Revision 9</span></strong><span> Varna 2023</span>
<ul>
<li><span>All preconditions on </span><code>sz &lt; capacity</code><span> are now a "Throws </span><code>bad_alloc</code><span>" with the exception of the "</span><code>unchecked_</code><span>" family of functions.</span></li>
<li><span>The "</span><code>try_</code><span>" family of insertion functions do not consume the input rvalue references if the container is full.</span></li>
<li><span>Container move / copy constructor are trivial if </span><code>T</code><span> is trivial  move / copy constructible.</span></li>
<li><span>Swap member function is now noexcept if </span><code>N == 0</code><span> or value type has nothrow move constructors.</span></li>
<li><span>Made complexity of resize linear.</span></li>
<li><span>Fixed out-of-bounds math in wording (less than equal to vs less).</span></li>
<li><span>Fixed constraints on all the "</span><code>emplace</code><span> family" of functions.</span></li>
<li><span>Fixed constraints of unary constructor taking a size to require default insertability instead of copy insertability.</span></li>
<li><span>Fixed missing angle brackets on </span><code>&lt;inplace_vector&gt;</code><span> header and listed headers alphabetically.</span></li>
<li><span>Cleanup: removed duplicates of preconditions that are covered in the sequence container requirements.</span></li>
<li><span>Cleanup: removed unnecessary specification of member swap and specialized algorithms.</span></li>
<li><span>Styling: use </span><code>class</code><span> instead of </span><code>typename</code><span> in template heads, replace </span><code>value_type</code><span> with </span><code>T</code><span> in wording, </span><code>bad_alloc</code><span> in code font, etc.</span></li>
</ul>
</li>
<li><strong><span>Revision 8</span></strong><span> Varna 2023</span>
<ul>
<li><span>Added LEWG poll showing consensus for </span><code>&lt;inplace_vector&gt;</code><span> header.</span></li>
<li><span>Add feature test macro</span></li>
<li><span>Add </span><code>try_push_back</code><span> and </span><code>unchecked_push_back</code><span> to wording.</span></li>
<li><span>Add </span><code>at</code><span> to </span><code>inplace_vector</code><span> class synopsis.</span></li>
<li><span>Add range construction and assignment.</span></li>
<li><span>Add missing </span><code>reserve</code><span> method that throws </span><code>bad_alloc</code><span> if </span><code>capacity()</code><span> is exceeded.</span></li>
<li><span>Add missing </span><code>shrink_to_fit</code><span> method that has no effects.</span></li>
<li><span>Add missing </span><code>insert_range</code><span>.</span></li>
<li><span>Add wording for move constructor semantics (trivial if </span><code>T</code><span> is trivial).</span></li>
<li><span>Add wording for destructor semantics (trivial if </span><code>T</code><span> is trivial).</span></li>
<li><span>Remove deduction guidelines since cannot deduce </span><code>capacity()</code><span> meaningfully.</span></li>
<li><span>Add to containers.sequences.general.</span></li>
<li><span>Add to sequence containers table.</span></li>
<li><span>Add to iterator.range.</span></li>
<li><span>Add to diff.cpp03.library.</span></li>
<li><span>Add poll result confirming unchecked_push_back.</span></li>
<li><span>Add erasure.</span></li>
<li><span>Add poll result confirming the overall design.</span></li>
<li><span>Review synopsis/wording for other missing functions.</span></li>
<li><span>Update </span><code>operator==</code><span> to </span><code>operator&lt;=&gt;</code><span> using hidden friends for them.</span></li>
<li><span>Made </span><code>&lt;inplace_vector&gt;</code><span> not freestanding (this will be handled in a separate paper).</span></li>
</ul>
</li>
<li><strong><span>Revision 7</span></strong><span> Varna 2023</span>
<ul>
<li><span>Rename </span><code>static_vector</code><span> to </span><code>inplace_vector</code><span> throughout.</span></li>
<li><span>Update </span><code>try_push_back</code><span> APIs to return </span><code>T*</code><span> with rationale.</span></li>
<li><span>Update </span><code>push_back</code><span> to throw </span><code>std::bad_alloc</code><span> with rationale .</span></li>
<li><span>Trivially-copyable if </span><code>value_type</code><span> is trivially-copyable.</span></li>
<li><span>Request LEWG poll regarding ``</span>&lt;vector&gt;<code>or</code><span>&lt;inplace_vector&gt;` header.</span></li>
<li><span>Make </span><code>push_back</code><span> return a reference</span></li>
</ul>
</li>
<li><strong><span>Revision 6</span></strong><span>: for Varna 2023 following Kona's 2022 guidance</span>
<ul>
<li><span>Updated push_back semantics to follow std::vector (note about exception to throw).</span></li>
<li><span>Added </span><code>try_push_back</code><span> returning an </span><code>optional</code></li>
<li><span>Added </span><code>push_back_unchecked</code><span>: excedding capacity exhibits undefined behavior.</span></li>
<li><span>Added note about naming.</span></li>
</ul>
</li>
<li><strong><span>Revision 5</span></strong><span>:</span>
<ul>
<li><span>Update contact wording and contact data.</span></li>
<li><span>Removed naming discussion, since it was resolved (last available in </span><a href="https://wg21.link.p0843r4" target="_blank" rel="noopener"><span>P0843r4</span></a><span>).</span></li>
<li><span>Removed future extensions discussion (last available in </span><a href="https://wg21.link.p0843r4" target="_blank" rel="noopener"><span>P0843r4</span></a><span>).</span></li>
<li><span>Addressed LEWG feedback regarding move-semantics and exception-safety.</span></li>
</ul>
</li>
<li><strong><span>Revision 4</span></strong><span>:</span>
<ul>
<li><span>LEWG suggested that push_back should be UB when the capacity is exceeded</span></li>
<li><span>LEWG suggested that this should be a free-standing header</span></li>
</ul>
</li>
<li><strong><span>Revision 3</span></strong><span>:</span>
<ul>
<li><span>Include LWG design questions for LEWG.</span></li>
<li><span>Incorporates LWG feedback.</span></li>
</ul>
</li>
<li><strong><span>Revision 2</span></strong>
<ul>
<li><span>Replace the placeholder name </span><code>fixed_capacity_vector</code><span> with </span><code>static_vector</code></li>
<li><span>Remove at checked element access member function.</span></li>
<li><span>Add changelog section.</span></li>
</ul>
</li>
<li><strong><span>Revision 1</span></strong>
<ul>
<li><span>Minor style changes and bugfixes.</span></li>
</ul>
</li>
</ul><h1 id="Introduction" data-id="Introduction"><a class="anchor hidden-xs" href="#Introduction" title="Introduction"><span class="octicon octicon-link"></span></a><span>Introduction</span></h1><p><span>This paper proposes </span><code>inplace_vector</code><span>, a dynamically-resizable array with capacity fixed at compile time and contiguous inplace storage, that is, the array elements are stored within the vector object itself. Its API closely resembles </span><code>std::vector&lt;T, A&gt;</code><span>, making it easy to teach and learn, and the </span><em><span>inplace storage</span></em><span> guarantee makes it useful in environments in which dynamic memory allocations are undesired.</span></p><p><span>This container is widely-used in the standard practice of C++, with prior art in, e.g., </span><a href="http://www.boost.org/doc/libs/1_59_0/doc/html/boost/container/static_vector.html" target="_blank" rel="noopener"><code>boost::static_vector&lt;T, Capacity&gt;</code><span> [1]</span></a><span> or the </span><a href="https://github.com/questor/eastl/blob/master/fixed_vector.h#L71" target="_blank" rel="noopener"><span>EASTL [2]</span></a><span>, and therefore we believe it will be very useful to expose it as part of the C++ standard library, which will enable it to be used as a vocabulary type.</span></p><h1 id="Motivation-and-Scope" data-id="Motivation-and-Scope"><a class="anchor hidden-xs" href="#Motivation-and-Scope" title="Motivation-and-Scope"><span class="octicon octicon-link"></span></a><span>Motivation and Scope</span></h1><p><span>The </span><code>inplace_vector</code><span> container is useful when:</span></p><ul>
<li><span>memory allocation is not possible, e.g., embedded environments without a free store, where only automatic storage and static memory are available;</span></li>
<li><span>memory allocation imposes an unacceptable performance penalty, e.g., in terms of latency;</span></li>
<li><span>allocation of objects with complex lifetimes in the </span><em><span>static</span></em><span>-memory segment is required;</span></li>
<li><span>the storage location of the </span><code>inplace_vector</code><span> elements is required to be within  the </span><code>inplace_vector</code><span> object itself, e.g., for serialization purposes (e.g. via </span><code>memcpy</code><span>);</span></li>
<li><code>std::array</code><span> is not an option, e.g., if non-default constructible objects must be stored; or</span></li>
<li><span>a dynamically-resizable array is needed during constant evaluation.</span></li>
</ul><h1 id="Existing-practice" data-id="Existing-practice"><a class="anchor hidden-xs" href="#Existing-practice" title="Existing-practice"><span class="octicon octicon-link"></span></a><span>Existing practice</span></h1><p><span>Three widely used implementations of </span><code>inplace_vector</code><span> are available: </span><a href="http://www.boost.org/doc/libs/1_59_0/doc/html/boost/container/static_vector.html" target="_blank" rel="noopener"><span>Boost.Container [1]</span></a><span>, </span><a href="https://github.com/questor/eastl/blob/master/fixed_vector.h#L71" target="_blank" rel="noopener"><span>EASTL [2]</span></a><span>, and </span><a href="https://github.com/facebook/folly/blob/master/folly/docs/small_vector.md" target="_blank" rel="noopener"><span>Folly [3]</span></a><span>. </span><code>Boost.Container</code><span> implements </span><code>inplace_vector</code><span> as a standalone type with its own guarantees. </span><a href="https://github.com/questor/eastl/blob/master/fixed_vector.h#L71" target="_blank" rel="noopener"><span>EASTL</span></a><span> and </span><a href="https://github.com/facebook/folly/blob/master/folly/docs/small_vector.md" target="_blank" rel="noopener"><span>Folly</span></a><span> implement it via an extra template parameter in their </span><code>small_vector</code><span> types.</span></p><p><span>Custom allocators like </span><a href="https://howardhinnant.github.io/stack_alloc.html" target="_blank" rel="noopener"><span>Howard Hinnant's </span><code>stack_alloc</code><span> [4]</span></a><span> emulate </span><code>inplace_vector</code><span> on top of </span><code>std::vector</code><span>, but as discussed in the next sections, this emulation is not great.</span></p><p><span>Other prior art includes the following.</span></p><ul>
<li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0494r0.pdf" target="_blank" rel="noopener"><span>P0494R0: </span><code>contiguous_container</code><span> proposal [5]</span></a><span>: proposes a </span><code>Storage</code><span> concept.</span></li>
<li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0597r0.html" target="_blank" rel="noopener"><span>P0597R0: </span><code>std::constexpr_vector&lt;T&gt;</code><span> [6]</span></a><span>: proposes a vector that can only be used in constexpr contexts.</span></li>
</ul><p><span>A reference implementation of this proposal is available </span><a href="https://godbolt.org/z/5P78aG5xE" target="_blank" rel="noopener"><span>here (godbolt)</span></a><span>.</span></p><h1 id="Design" data-id="Design"><a class="anchor hidden-xs" href="#Design" title="Design"><span class="octicon octicon-link"></span></a><span>Design</span></h1><p><span>The design described below was approved at </span><a href="" target="_blank" rel="noopener"><span>LEWG Varna '23</span></a><span>:</span></p><ul>
<li><strong><span>POLL:</span></strong><span> The provided signatures and semantics that D08437R7 provides for push_back, emplace_back, try_push_back, try_emplace_back, and the unchecked versions are acceptable.</span></li>
</ul><table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>9</span></td>
<td><span>7</span></td>
<td><span>0</span></td>
<td><span>0</span></td>
<td><span>0</span></td>
</tr>
</tbody>
</table><ul>
<li><strong><span>POLL</span></strong><span>: We approve the design of D0843R7 (inplace_vector) with the changes already polled.</span></li>
</ul><table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>11</span></td>
<td><span>5</span></td>
<td><span>0</span></td>
<td><span>0</span></td>
<td><span>0</span></td>
</tr>
</tbody>
</table><h2 id="Standalone-or-a-special-case-another-type" data-id="Standalone-or-a-special-case-another-type"><a class="anchor hidden-xs" href="#Standalone-or-a-special-case-another-type" title="Standalone-or-a-special-case-another-type"><span class="octicon octicon-link"></span></a><span>Standalone or a special case another type?</span></h2><p><span>The </span><a href="https://github.com/questor/eastl/blob/master/fixed_vector.h#L71" target="_blank" rel="noopener"><span>EASTL</span></a><span> [2] and </span><a href="https://github.com/facebook/folly/blob/master/folly/docs/small_vector.md" target="_blank" rel="noopener"><span>Folly</span></a><span> [3] special case </span><code>small_vector</code><span>, e.g., using a fourth template parameter, to make it become an </span><code>inplace_vector</code><span>. </span><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0639r0.html" target="_blank" rel="noopener"><span>P0639R0: </span><em><span>Changing attack vector of the </span><code>constexpr_vector</code></em><span> [7]</span></a><span> proposes improving the </span><code>Allocator</code><span> concepts to allow implementing </span><code>inplace_vector</code><span> as a special case of </span><code>vector</code><span> with a custom allocator. Both approaches produce specializations of </span><code>small_vector</code><span> or </span><code>vector</code><span> whose methods differ subtly in terms of effects, exception safety, iterator invalidation, and complexity guarantees.</span></p><p><span>This proposal closely follows </span><a href="http://www.boost.org/doc/libs/1_59_0/doc/html/boost/container/static_vector.html" target="_blank" rel="noopener"><code>boost::container::static_vector&lt;T,Capacity&gt;</code><span> [1]</span></a><span> and proposes </span><code>inplace_vector</code><span> as a standalone type.</span></p><p><span>Where possible, this proposal defines the semantics of </span><code>inplace_vector</code><span> to match </span><code>vector</code><span>. Providing the same programming model makes this type easier to teach and use, and makes it easy to "just change" one type in a program to, e.g., perform a performance experiment without accidentally introducing undefined behavior.</span></p><h2 id="Layout" data-id="Layout"><a class="anchor hidden-xs" href="#Layout" title="Layout"><span class="octicon octicon-link"></span></a><span>Layout</span></h2><p><code>inplace_vector</code><span> models </span><code>ContiguousContainer</code><span>. Its elements are stored and properly aligned within the </span><code>inplace_vector</code><span> object itself. If the </span><code>Capacity</code><span> is zero the container has zero size:</span></p><pre><code class="cpp hljs"><span class="token keyword">static_assert</span><span class="token punctuation">(</span>is_empty_v<span class="token operator">&lt;</span>inplace_vector<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> <span class="token number">0</span><span class="token operator">&gt;&gt;</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// for all T</span>
</code></pre><p><span>The offset of the first element within </span><code>inplace_vector</code><span> is unspecified, and </span><code>T</code><span>s are not allowed to overlap.</span></p><p><span>The layout differs from </span><code>vector</code><span>, since </span><code>inplace_vector</code><span> does not store the </span><code>capacity</code><span> field (it's known from the template parameter).</span></p><p><span>If </span><code>T</code><span> is trivially-copyable or </span><code>N == 0</code><span>, then </span><code>inplace_vector&lt;T, N&gt;</code><span> is also trivially copyable to support high-performance computing (HPC) use cases, such as the following.</span></p><ul>
<li><span>Copying between host and accelerator memory spaces.  Examples of accelerators include Graphics Processing Units (GPUs).</span></li>
<li><span>Serialization and deserialization for distributed-memory parallel communication, e.g., sending a vector via the </span><code>MPI_Send</code><span> function from the Message Passing Interface (MPI).</span></li>
</ul><pre><code class="cpp hljs"><span class="token comment">// for all C:</span>
<span class="token keyword">static_assert</span><span class="token punctuation">(</span><span class="token operator">!</span>is_trivially_copyable_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> <span class="token operator">||</span> is_trivially_copyable_v<span class="token operator">&lt;</span>inplace_vector<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> C<span class="token operator">&gt;&gt;</span> <span class="token operator">||</span> N <span class="token operator">==</span> <span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><h2 id="Move-semantics" data-id="Move-semantics"><a class="anchor hidden-xs" href="#Move-semantics" title="Move-semantics"><span class="octicon octicon-link"></span></a><span>Move semantics</span></h2><p><span>A moved-from </span><code>inplace_vector</code><span> is left in a </span><em><span>valid but unspecified state</span></em><span> (option 3 below) unless </span><code>T</code><span> is trivially-copyable, in which case the size of the </span><code>inplace_vector</code><span> does not change (</span><code>array</code><span> semantics, option 2 below). That is:</span></p><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span></div><div class="code">inplace_vector <span class="token function">a</span><span class="token punctuation">(</span><span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
inplace_vector <span class="token function">b</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>a<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token function">assert</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span><span class="token function">size</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">==</span> <span class="token number">10</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// MAY FAIL</span>
</div></div></code></pre><p><span>moves </span><code>a</code><span>'s elements element-wise into </span><code>b</code><span>, and afterwards the size of the moved-from </span><code>inplace_vector</code><span> may have changed.</span></p><p><span>This prevents code from relying on the size staying the same (and therefore being incompatible with changing an </span><code>inplace_vector</code><span> type back to </span><code>vector</code><span>) without incuring the cost of having to clear the </span><code>inplace_vector</code><span>.</span></p><p><span>When </span><code>T</code><span> is trivially-copyable, </span><code>array</code><span> semantics are used to provide trivial move operations.</span></p><p><span>This is different from </span><a href="https://github.com/cplusplus/papers/issues/114#issuecomment-1312015872" target="_blank" rel="noopener"><span>LEWG Kona '22 Polls</span></a><span> (22 in person + 8 remote) and we'd like to poll on these semantics again:</span></p><ul>
<li>
<p><strong><span>POLL</span></strong><span>: Moving a static_vector should empty it (vector semantics).</span></p>
<table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>9</span></td>
<td><span>10</span></td>
<td><span>4</span></td>
<td><span>2</span></td>
<td><span>2</span></td>
</tr>
</tbody>
</table>
</li>
<li>
<p><strong><span>POLL</span></strong><span>: Moving a static_vector should leave it in a valid but unspecified state.</span></p>
<table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>6</span></td>
<td><span>9</span></td>
<td><span>1</span></td>
<td><span>5</span></td>
<td><span>6</span></td>
</tr>
</tbody>
</table>
</li>
</ul><p><strong><span>Alternatives</span></strong><span>:</span></p><ol>
<li><code>vector</code><span> semantics: guarantees that </span><code>inplace_vector</code><span> is left empty (this happens with move assignment when using </span><code>std::allocator&lt;T&gt;</code><span> and always with move construction).</span>
<ul>
<li><span>Pro: same programming model as </span><code>vector</code><span>.</span></li>
<li><span>Pro: increases safety by requiring users to re-initialize vector elements.</span></li>
<li><span>Con: clearing an </span><code>inplace_vector</code><span> is not free.</span></li>
<li><span>Con: </span><code>inplace_vector&lt;T, N&gt;</code><span> can no longer be made trivially copyable for a trivially copyable </span><code>T</code><span>, as the move operations can no longer be trivial.</span></li>
</ul>
</li>
<li><code>array</code><span> semantics: guarantees that </span><code>size()</code><span> of </span><code>inplace_vector</code><span> does not change, and that elements are left in their moved-from state.</span>
<ul>
<li><span>Pro: no additional run-time cost incurred.</span></li>
<li><span>Con: different programming model than </span><code>vector</code><span>.</span></li>
</ul>
</li>
<li><span>"valid but unspecified state"</span>
<ul>
<li><span>Con: different programming model than </span><code>vector</code><span> and </span><code>array</code><span>, requires calling </span><code>size()</code></li>
<li><span>Pro: code calling </span><code>size()</code><span> is correct for both </span><code>vector</code><span> and </span><code>inplace_vector</code><span>, enabling changing the type back and forth.</span></li>
</ul>
</li>
</ol><h2 id="constexpr-support" data-id="constexpr-support"><a class="anchor hidden-xs" href="#constexpr-support" title="constexpr-support"><span class="octicon octicon-link"></span></a><code>constexpr</code><span> support</span></h2><blockquote>
<p><span>Note: this revision brings back this section which was dropped in R8 because per LEWG discussion, LEWG thought that this whole type was implementable within constexpr for all types. The design intent of LEWG was to make it "as </span><code>constexpr</code><span> as possible."</span></p>
</blockquote><p><span>The API of </span><code>inplace_vector&lt;T, Capacity&gt;</code><span> can be used in constexpr-contexts if </span><code>is_trivially_copyable_v&lt;T&gt;</code><span>, </span><code>is_default_constructible_v&lt;T&gt;</code><span>, and </span><code>is_trivially_destructible&lt;T&gt;</code><span> are true.</span></p><p><span>The implementation cost of this is small. The prototye implementation specializes the storage to use a C array with value-initialized elements.</span></p><p><span>This negatively impacts the algorithmic complexity of inplace_vector constructors for these types from O(size) to O(capacity). When value-initialization takes place at run-time, this difference is significant.</span></p><p><span>Vectors with large capacity requirements are better served by vector instead.</span></p><h2 id="Exception-Safety" data-id="Exception-Safety"><a class="anchor hidden-xs" href="#Exception-Safety" title="Exception-Safety"><span class="octicon octicon-link"></span></a><span>Exception Safety</span></h2><p><span>When using the </span><code>inplace_vector</code><span> APIs, the following types of failures are expected:</span></p><ul>
<li>
<p><span>May throw:</span></p>
<ol>
<li><span>The </span><code>value_type</code><span>'s constructors/assignment/destructors/swap (depends on </span><code>noexcept</code><span>),</span></li>
<li><span>Mutating operations exceeding the capacity (</span><code>push_back</code><span>, </span><code>insert</code><span>, </span><code> </code><span>, </span><code>inplace_vector(value_type, size)</code><span>, </span><code>inplace_vector(begin, end)</code><span class="smartypants">…</span><span>), and</span></li>
<li><span>Out-of-bounds checked access: </span><code>at</code><span>.</span></li>
</ol>
</li>
<li>
<p><span>Pre-condition violation:</span></p>
<ol>
<li><span>Out-of-bounds unchecked access: </span><code>front</code><span>/</span><code>back</code><span>/</span><code>pop_back</code><span> when empty, </span><code>operator[]</code><span>.</span></li>
</ol>
</li>
</ul><h3 id="Exception-Safety-guarantees-of-Mutating-Operations" data-id="Exception-Safety-guarantees-of-Mutating-Operations"><a class="anchor hidden-xs" href="#Exception-Safety-guarantees-of-Mutating-Operations" title="Exception-Safety-guarantees-of-Mutating-Operations"><span class="octicon octicon-link"></span></a><span>Exception Safety guarantees of Mutating Operations</span></h3><p><span>When an </span><code>inplace_vector</code><span> API throws an exception,</span></p><ul>
<li><em><span>Basic Exception Guarantee</span></em><span> requires the API to leave the </span><code>inplace_vector</code><span> in a valid state.</span></li>
<li><em><span>Strong Exception Guarantee</span></em><span> requires the API to roll back the </span><code>inplace_vector</code><span> state to that of before the API was called, e.g., removing previously inserted elements, and loosing data when inserting from input iterators or ranges.</span></li>
</ul><p><span>The following alternative were considered:</span></p><ol>
<li><span>Same guarantees as their counter-part </span><code>vector</code><span> APIs.</span></li>
<li><span>Always provide the </span><em><span>Basic Guarantee</span></em><span> independent on the concepts implemented by the iterators/ranges: always insert up to the capacity, then throw.</span></li>
<li><span>Provide different exception safety guarantees depending on the concepts modeled by the iterators/ranges API arguments:</span>
<ul>
<li><code>sized_range</code><span>,  </span><code>random_access_iterator</code><span>, or </span><code>LegacyRandomAccessIterator</code><span>: </span><em><span>Strong guarantee</span></em><span>, i.e., if the capacity would be exceeded, the API throws without attempting to insert any elements. This performs well and the caller looses no data.</span></li>
<li><span>Otherwise: </span><em><span>Basic guarantee</span></em><span>, i.e., elements are inserted up to the capacity, and are not removed before throwing. This performs well and the caller only looses data, e.g., stashed in discarded input iterators.</span></li>
</ul>
</li>
</ol><p><span>We propose to, unless stated otherwise, </span><code>inplace_vector</code><span> APIs should provide the same exception safety guarantees as their counter-part </span><code>vector</code><span> APIs.</span></p><h3 id="Exception-thrown-by-mutating-operations-exceeding-capacity" data-id="Exception-thrown-by-mutating-operations-exceeding-capacity"><a class="anchor hidden-xs" href="#Exception-thrown-by-mutating-operations-exceeding-capacity" title="Exception-thrown-by-mutating-operations-exceeding-capacity"><span class="octicon octicon-link"></span></a><span>Exception thrown by mutating operations exceeding capacity</span></h3><p><span>We propose that mutating operations that exceed the capacity throw </span><code>bad_alloc</code><span>, to make it safer for applications handling out of memory errors to introduce </span><code>inplace_vector</code><span> as a performance optimization by replacing </span><code>vector</code><span>.</span></p><p><span>LEWG revisited the rationale below and decided to keep throwing </span><code>bad_alloc</code><span> in the 2024-01-30 telecon.</span></p><p><strong><span>Alternatives</span></strong><span>:</span></p><ol>
<li><span>Throw </span><code>bad_alloc</code><span>: </span><code>inplace_vector</code><span> requests storage from "allocator embedded within the </span><code>inplace_vector</code><span>", which fails to allocate, and therefore throws </span><code>bad_alloc</code><span> (e.g. like </span><code>vector</code><span> and </span><code>pmr</code><span> "stack allocator").</span>
<ul>
<li><strong><span>Pros</span></strong><span>: handling </span><code>bad_alloc</code><span> is more common than other exceptions when attempting to handle failure to insert due to "out-of-memory".</span></li>
</ul>
</li>
<li><span>Throw </span><code>length_error</code><span>: insertion exceeds </span><code>max_size</code><span> and therefore throws </span><code>length_error</code>
<ul>
<li><strong><span>Pros</span></strong><span>: container requirements already imply that this exception may be thrown.</span></li>
<li><strong><span>Cons</span></strong><span>: handling </span><code>length_error</code><span> is rare since it is usually very high.</span></li>
</ul>
</li>
<li><span>Throw "some other exception" when the </span><code>inplace_vector</code><span> is out-of-memory:</span>
<ul>
<li><strong><span>Pros</span></strong><span>: to be determined.</span></li>
<li><strong><span>Cons</span></strong><span>: different programming model as </span><code>vector</code><span>.</span></li>
</ul>
</li>
<li><span>Abort the process</span>
<ul>
<li><strong><span>Pros</span></strong><span>: portability to embedded platforms without exception support</span></li>
<li><strong><span>Cons</span></strong><span>: different programming model than </span><code>vector</code></li>
</ul>
</li>
<li><span>Precondition violation</span>
<ul>
<li><strong><span>Cons</span></strong><span>: different proramming model than </span><code>vector</code><span>, users responsible for checking before modifying vector size, etc.</span></li>
</ul>
</li>
</ol><h2 id="Fallible-APIs" data-id="Fallible-APIs"><a class="anchor hidden-xs" href="#Fallible-APIs" title="Fallible-APIs"><span class="octicon octicon-link"></span></a><span>Fallible APIs</span></h2><p><span>We add the following new fallible APIs which, when the vector size equal its capacity, return </span><code>nullptr</code><span> (and do not throw </span><code>bad_alloc</code><span>) without moving from the inputs, enabling them to be re-used:</span></p><pre><code class="cpp hljs"><span class="token keyword">constexpr</span> T<span class="token operator">*</span> <span class="token class-name">inplace_vector</span><span class="token operator">&lt;</span>T<span class="token punctuation">,</span> C<span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span><span class="token function">try_push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">constexpr</span> T<span class="token operator">*</span> <span class="token class-name">inplace_vector</span><span class="token operator">&lt;</span>T<span class="token punctuation">,</span> C<span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span><span class="token function">try_push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span> 

<span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token keyword">constexpr</span> T<span class="token operator">*</span> <span class="token function">try_emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token keyword">template</span><span class="token operator">&lt;</span> container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token keyword">constexpr</span> ranges<span class="token double-colon punctuation">::</span>iterator_t<span class="token operator">&lt;</span>R<span class="token operator">&gt;</span> <span class="token function">try_append_range</span><span class="token punctuation">(</span>R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>The </span><code>try_append_range</code><span> API always tries to insert all </span><code>rg</code><span> range elements up to either the vector capacity or the range </span><code>rg</code><span> is exhausted. It returns an iterator to the first non-inserted element of </span><code>rg</code><span> or the end iterator of </span><code>rg</code><span> if the range was exhausted. It intentionally provides the Basic Exception Safety guarantee, i.e., if inserting an element throws, previously succesfully inserted elements are preserved in the vector (i.e. not lost).</span></p><p><span>These APIs may be used as follows:</span></p><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code">T value <span class="token operator">=</span> <span class="token function">T</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">if</span> <span class="token punctuation">(</span><span class="token operator">!</span>v<span class="token punctuation">.</span><span class="token function">try_push_back</span><span class="token punctuation">(</span>value<span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    std<span class="token double-colon punctuation">::</span>cerr <span class="token operator">&lt;&lt;</span> <span class="token string">"Failed to insert "</span> <span class="token operator">&lt;&lt;</span> value <span class="token operator">&lt;&lt;</span> std<span class="token double-colon punctuation">::</span>endl<span class="token punctuation">;</span> <span class="token comment">// value not moved-from</span>
    std<span class="token double-colon punctuation">::</span><span class="token function">terminate</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">auto</span> il <span class="token operator">=</span> <span class="token punctuation">{</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">if</span> <span class="token punctuation">(</span>v<span class="token punctuation">.</span><span class="token function">try_append_range</span><span class="token punctuation">(</span>il<span class="token punctuation">)</span> <span class="token operator">!=</span> <span class="token function">end</span><span class="token punctuation">(</span>il<span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token comment">// The vector capacity was exhausted</span>
    std<span class="token double-colon punctuation">::</span><span class="token function">terminate</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</div></div></code></pre><h2 id="Fallible-Unchecked-APIs" data-id="Fallible-Unchecked-APIs"><a class="anchor hidden-xs" href="#Fallible-Unchecked-APIs" title="Fallible-Unchecked-APIs"><span class="octicon octicon-link"></span></a><span>Fallible Unchecked APIs</span></h2><p><span>We add the following new fallible unchecked APIs for which exceeding the capacity is a precondition violation:</span></p><pre><code class="cpp hljs"><span class="token keyword">constexpr</span> T<span class="token operator">&amp;</span> <span class="token class-name">inplace_vector</span><span class="token operator">&lt;</span>T<span class="token punctuation">,</span> C<span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span><span class="token function">unchecked_push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">constexpr</span> T<span class="token operator">&amp;</span> <span class="token class-name">inplace_vector</span><span class="token operator">&lt;</span>T<span class="token punctuation">,</span> C<span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span><span class="token function">unchecked_push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token keyword">constexpr</span> T<span class="token operator">&amp;</span> <span class="token function">unchecked_emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>The </span><code>append_range</code><span> API was requested during LWG review in December 2023.</span></p><p><span>These APIs were requested in </span><a href="https://github.com/cplusplus/papers/issues/114#issuecomment-1312015872" target="_blank" rel="noopener"><span>LEWG Kona '22</span></a><span> (22 in person + 8 remote):</span></p><ul>
<li>
<p><strong><span>POLL</span></strong><span>: If static_vector has unchecked operations (e.g. </span><code>push_back_unchecked</code><span>), it is okay for checked operations (e.g. </span><code>push_back</code><span>) to throw when they run out of space.</span></p>
<table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>14</span></td>
<td><span>4</span></td>
<td><span>2</span></td>
<td><span>4</span></td>
<td><span>1</span></td>
</tr>
</tbody>
</table>
</li>
</ul><p><span>This was confirmed at </span><a href="" target="_blank" rel="noopener"><span>LEWG Varna '23</span></a><span> after a discussion on safety:</span></p><ul>
<li><strong><span>POLL</span></strong><span>: D0843R7 should remove the unchecked versions of push_back and emplace_back</span></li>
</ul><table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>1</span></td>
<td><span>5</span></td>
<td><span>3</span></td>
<td><span>3</span></td>
<td><span>7</span></td>
</tr>
</tbody>
</table><p><span>The name </span><code>unchecked_push_back</code><span> was polled in </span><a href="" target="_blank" rel="noopener"><span>LEWG Varna '23</span></a><span>:</span></p><ul>
<li>
<p><strong><span>POLL</span></strong><span>: (vote for all the options you find acceptable, vote as many times as you like) Feature naming</span></p>
<table>
<thead>
<tr>
<th><span>Feature name</span></th>
<th><span>Votes</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>push_back_unchecked</span></td>
<td><span>11</span></td>
</tr>
<tr>
<td><span>unchecked_push_back</span></td>
<td><span>16</span></td>
</tr>
<tr>
<td><span>unsafe_push_back</span></td>
<td><span>9</span></td>
</tr>
<tr>
<td><span>push_back_unsafe</span></td>
<td><span>6</span></td>
</tr>
</tbody>
</table>
</li>
</ul><p><span>The potential impact of the three APIs on code size and performance is shown </span><a href="https://clang.godbolt.org/z/MbG17q8x1" target="_blank" rel="noopener"><span>here</span></a><span>, where the main difference between </span><code>try_push_back</code><span> and </span><code>unchecked_push_back</code><span> is the presence of an extra branch in </span><code>try_push_back</code><span>.</span></p><h2 id="Allocator-awareness" data-id="Allocator-awareness"><a class="anchor hidden-xs" href="#Allocator-awareness" title="Allocator-awareness"><span class="octicon octicon-link"></span></a><span>Allocator awareness</span></h2><p><span>We believe that right now, making </span><code>inplace_vector</code><span> allocator-aware does not outweigh its complexity and design cost. We can always provide a way to support that in the future.</span></p><p><span>Options:</span></p><ul>
<li><code>inplace_vector</code><span> is allocator-aware if its </span><code>value_type</code><span> is allocator-aware.</span></li>
<li><span>factoring an allocator-aware </span><code>inplace_vector</code><span> into a separate </span><code>basic_allocator</code><span> class.</span></li>
<li><span>no support for now (not worth delaying further)</span></li>
</ul><h2 id="Iterator-invalidation" data-id="Iterator-invalidation"><a class="anchor hidden-xs" href="#Iterator-invalidation" title="Iterator-invalidation"><span class="octicon octicon-link"></span></a><span>Iterator invalidation</span></h2><p><code>inplace_vector</code><span> iterator invalidation guarantees differ from </span><code>std::vector</code><span>:</span></p><ul>
<li><span>moving a </span><code>inplace_vector</code><span> invalidates all iterators, and</span></li>
<li><span>swapping two </span><code>inplace_vector</code><span>s invalidates all iterators.</span></li>
</ul><p><code>inplace_vector</code><span> APIs that potentially invalidate iterators are: </span><code>resize(n)</code><span>, </span><code>resize(n, v)</code><span>, </span><code>pop_back</code><span>, </span><code>erase</code><span>, and </span><code>swap</code><span>.</span></p><h2 id="Freestanding" data-id="Freestanding"><a class="anchor hidden-xs" href="#Freestanding" title="Freestanding"><span class="octicon octicon-link"></span></a><span>Freestanding</span></h2><p><span>Many</span><code>inplace_vector</code><span> APIs are not available in freestanding because fallible insertion APIs (constructors, push back, insert, </span><span class="smartypants">…</span><span>) may throw.</span></p><p><span>The infallible </span><code>try_</code><span> APIs do not throw and are available in freestanding. They only cover a subset of the functionality available through fallible APIs. This is intentional. Adding more infallible APIs to </span><code>inplace_vector</code><span> and potentially other containers is left as future work.</span></p><p><span>We'd need to add it to: </span><a href="http://eel.is/c++draft/compliance" target="_blank" rel="noopener"><span>[library.requirements.organization.compliance]</span></a></p><p><span>When we fix this we'd need to add  </span><code>&lt;inplace_vector&gt;</code><span> to </span><a href="http://eel.is/c++draft/tab:headers.cpp.fs" target="_blank" rel="noopener"><span>[tab:headers.cpp.fs]</span></a><span>:</span></p><table>
<thead>
<tr>
<th></th>
<th><span>Subclause</span></th>
<th><span>Headers</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><ins><a href="http://eel.is/c++draft/containers" target="_blank" rel="noopener"><span>[containers]</span></a></ins></td>
<td><ins><span>containers</span></ins></td>
<td><ins><code>&lt;inplace_vector&gt;</code></ins></td>
</tr>
</tbody>
</table><h2 id="Same-or-Separate-header" data-id="Same-or-Separate-header"><a class="anchor hidden-xs" href="#Same-or-Separate-header" title="Same-or-Separate-header"><span class="octicon octicon-link"></span></a><span>Same or Separate header</span></h2><p><span>We propose that this container goes into its own header </span><code>&lt;inplace_vector&gt;</code><span> rather than in header </span><code>&lt;vector&gt;</code><span>, because it is a sufficiently different container.</span></p><p><span>LWG asked for </span><code>inplace_vector</code><span> to be part of the </span><code>&lt;vector&gt;</code><span> header. </span><a href="" target="_blank" rel="noopener"><span>LEWG Varna '23</span></a><span> took the following poll:</span></p><ul>
<li>
<p><strong><span>POLL:</span></strong><span> D0843R7 should provide </span><code>inplace_vector</code><span> in </span><code>&lt;vector&gt;</code><span> rather than the proposal’s decision on </span><code>&lt;inplace_vector&gt;</code></p>
<table>
<thead>
<tr>
<th><span>Strongly Favor</span></th>
<th><span>Weakly Favor</span></th>
<th><span>Neutral</span></th>
<th><span>Weakly Against</span></th>
<th><span>Strongly Against</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>0</span></td>
<td><span>0</span></td>
<td><span>1</span></td>
<td><span>12</span></td>
<td><span>5</span></td>
</tr>
</tbody>
</table>
</li>
</ul><p><span>That is, consensus against change.</span></p><h2 id="Return-type-of-push_back" data-id="Return-type-of-push_back"><a class="anchor hidden-xs" href="#Return-type-of-push_back" title="Return-type-of-push_back"><span class="octicon octicon-link"></span></a><span>Return type of push_back</span></h2><p><span>In C++20, both </span><code>push_back</code><span> and </span><code>emplace_back</code><span> were slated to return a </span><code>reference</code><span> (they used to both return </span><code>void</code><span>).  Even with plenary approval, changing </span><code>push_back</code><span> turned out to be an ABI break that was backed out, leaving the situation where </span><code>emplace_back</code><span> returns a </span><code>reference</code><span> but </span><code>push_back</code><span> is still </span><code>void</code><span>.  This ABI issue doesn't apply to new types.  Should </span><code>push_back</code><span> return a </span><code>reference</code><span> to be consistent with </span><code>emplace_back</code><span>, or should it be consistent with older containers?</span></p><p><span>Request LEWG to poll on that.</span></p><h2 id="reserve-and-shrink_to_fit-APIs" data-id="reserve-and-shrink_to_fit-APIs"><a class="anchor hidden-xs" href="#reserve-and-shrink_to_fit-APIs" title="reserve-and-shrink_to_fit-APIs"><span class="octicon octicon-link"></span></a><code>reserve</code><span> and </span><code>shrink_to_fit</code><span> APIs</span></h2><p><code>shrink_to_fit</code><span> requests </span><code>vector</code><span> to decrease its </span><code>capacity</code><span>, but this request may be ignored. </span><code>inplace_vector</code><span> may implement it as a nop (and it may be </span><code>noexcept</code><span>).</span></p><p><code>reserve(n)</code><span> requests the </span><code>vector</code><span> to potentially increase its </span><code>capacity</code><span>, failing if the request can't be satisfied. </span><code>inplace_vector</code><span> may implement it as a nop if </span><code>n &lt;= capacity()</code><span>, throwing </span><code>bad_alloc</code><span> otherwise.</span></p><p><span>These APIs make it easier and safe for programs to be "more" parametric over "vector-like" containers (</span><code>vector</code><span>, </span><code>small_vector</code><span>, </span><code>inplace_vector</code><span>), but since they do not do anything useful for </span><code>inplace_vector</code><span>, we may want to fail to compile instead.</span></p><h2 id="Deduction-guides" data-id="Deduction-guides"><a class="anchor hidden-xs" href="#Deduction-guides" title="Deduction-guides"><span class="octicon octicon-link"></span></a><span>Deduction guides</span></h2><p><span>Unlike the other containers, </span><code>inplace_vector</code><span> does not have any deduction guides because there is no case in which it would be possible to deduce the second template argument, the capacity, from the initializer.</span></p><h2 id="Summary-of-semantic-differences-with-vector" data-id="Summary-of-semantic-differences-with-vector"><a class="anchor hidden-xs" href="#Summary-of-semantic-differences-with-vector" title="Summary-of-semantic-differences-with-vector"><span class="octicon octicon-link"></span></a><span>Summary of semantic differences with </span><code>vector</code></h2><table>
<thead>
<tr>
<th><strong><span>Aspect</span></strong></th>
<th><code>vector</code></th>
<th><code>inplace_vector</code></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>Capacity</span></td>
<td><span>Indefinite</span></td>
<td><code>N</code></td>
</tr>
<tr>
<td><span>Move and swap</span></td>
<td><span>O(1), no iterators invalidated</span></td>
<td><code>array</code><span> semantics: O(size), invalidates all iterators</span></td>
</tr>
<tr>
<td><span>Moved from</span></td>
<td><span>left empty (this happens with move assignment when using std::allocator</span>&lt;T&gt;<span> and always with move construction)</span></td>
<td><span>valid but unspecified state except if </span><code>T</code><span> is trivially-copyable, in which case </span><code>array</code><span> semantics</span></td>
</tr>
<tr>
<td><span>Default construction and destruction of trivial types</span></td>
<td><span>O(1)</span></td>
<td><span>O(capacity)</span></td>
</tr>
<tr>
<td><span>Is empty when zero capacity?</span></td>
<td><span>No</span></td>
<td><span>Yes</span></td>
</tr>
<tr>
<td><span>Trivially-copyable if </span><code>is_trivially_copyable_v&lt;T&gt;</code><span>?</span></td>
<td><span>No</span></td>
<td><span>Yes</span></td>
</tr>
</tbody>
</table><h2 id="Name" data-id="Name"><a class="anchor hidden-xs" href="#Name" title="Name"><span class="octicon octicon-link"></span></a><span>Name</span></h2><p><span>The class template name was confirmed at </span><a href="" target="_blank" rel="noopener"><span>LEWG Varna '23</span></a><span>:</span></p><ul>
<li><strong><span>POLL</span></strong><span>:  Feature naming</span></li>
</ul><table>
<thead>
<tr>
<th><span>Options</span></th>
<th><span>Votes</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><span>static_vector</span></td>
<td><span>4</span></td>
</tr>
<tr>
<td><span>inplace_vector</span></td>
<td><span>14</span></td>
</tr>
<tr>
<td><span>fixed_capacity_vector</span></td>
<td><span>5</span></td>
</tr>
</tbody>
</table><h1 id="Technical-specification" data-id="Technical-specification"><a class="anchor hidden-xs" href="#Technical-specification" title="Technical-specification"><span class="octicon octicon-link"></span></a><span>Technical specification</span></h1><p><bdi><strong><span>EDITORIAL:</span></strong><span> This enhancement is a pure header-only addition to the C++ standard library as the </span><code>&lt;inplace_vector&gt;</code><span> header. It belongs in the "Sequence containers" (</span><a href="http://eel.is/c++draft/sequences" target="_blank" rel="noopener"><span>[sequences]</span></a><span>) part of the "Containers library" (</span><a href="http://eel.is/c++draft/containers" target="_blank" rel="noopener"><span>[containers]</span></a><span>) as "Class template </span><code>inplace_vector</code><span>".</span></bdi></p><h2 id="libraryrequirementsorganizationheaders" data-id="libraryrequirementsorganizationheaders"><a class="anchor hidden-xs" href="#libraryrequirementsorganizationheaders" title="libraryrequirementsorganizationheaders"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/headers" target="_blank" rel="noopener"><span>[library.requirements.organization.headers]</span></a></h2><p><span>Add </span><ins><code>&lt;inplace_vector&gt;</code></ins><span> to </span><a href="http://eel.is/c++draft/tab:headers.cpp" target="_blank" rel="noopener"><span>[tab:headers.cpp]</span></a><span>.</span></p><p><span>Add  </span><code>&lt;inplace_vector&gt;</code><span> to </span><a href="http://eel.is/c++draft/tab:headers.cpp.fs" target="_blank" rel="noopener"><span>[tab:headers.cpp.fs]</span></a><span>:</span></p><table>
<thead>
<tr>
<th></th>
<th><span>Subclause</span></th>
<th><span>Headers</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><ins><a href="http://eel.is/c++draft/containers" target="_blank" rel="noopener"><span>[containers]</span></a></ins></td>
<td><ins><span>containers</span></ins></td>
<td><ins><code>&lt;inplace_vector&gt;</code></ins></td>
</tr>
</tbody>
</table><h2 id="iteratorrange-Range-access" data-id="iteratorrange-Range-access"><a class="anchor hidden-xs" href="#iteratorrange-Range-access" title="iteratorrange-Range-access"><span class="octicon octicon-link"></span></a><a href="https://eel.is/c++draft/iterator.range" target="_blank" rel="noopener"><span>[iterator.range]</span></a><span> Range access</span></h2><p><span>Modify:</span></p><p><a href="https://eel.is/c++draft/iterator.range#1" target="_blank" rel="noopener"><span>1</span></a><span> In addition to being available via inclusion of the </span><code>&lt;iterator&gt;</code><span> header, the function templates in </span><a href="https://eel.is/c++draft/iterator.range" target="_blank" rel="noopener"><span>[iterator.range]</span></a><span> are available when any of the following headers are included: </span><code>&lt;array&gt;</code><span>, </span><code>&lt;deque&gt;</code><span>, </span><code>&lt;forward_list&gt;</code><span>, </span><ins><code>&lt;inplace_vector&gt;</code><span>, </span></ins><code>&lt;list&gt;</code><span>, </span><code>&lt;map&gt;</code><span>, </span><code>&lt;regex&gt;</code><span>, </span><code>&lt;set&gt;</code><span>, </span><code>&lt;span&gt;</code><span>, </span><code>&lt;string&gt;</code><span>, </span><code>&lt;string_view&gt;</code><span>, </span><code>&lt;unordered_map&gt;</code><span>, </span><code>&lt;unordered_set&gt;</code><span>, and </span><code>&lt;vector&gt;</code><span>.</span></p><h2 id="containerallocreqmts" data-id="containerallocreqmts"><a class="anchor hidden-xs" href="#containerallocreqmts" title="containerallocreqmts"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/container.alloc.reqmts" target="_blank" rel="noopener"><span>[container.alloc.reqmts]</span></a></h2><p><span>Modify:</span></p><p><a href="http://eel.is/c++draft/container.alloc.reqmts#1" target="_blank" rel="noopener"><span>1</span></a><span> All of the containers defined in </span><a href="http://eel.is/c++draft/containers" target="_blank" rel="noopener"><span>[containers]</span></a><span> and in </span><a href="http://eel.is/c++draft/basic.string" target="_blank" rel="noopener"><span>[basic.string]</span></a><span> except </span><code>array</code><ins><span> and </span><code>inplace_vector</code></ins><span> meet the additional requirements of an allocator-aware container, as described below.</span></p><h2 id="allocatorrequirementsgeneral" data-id="allocatorrequirementsgeneral"><a class="anchor hidden-xs" href="#allocatorrequirementsgeneral" title="allocatorrequirementsgeneral"><span class="octicon octicon-link"></span></a><a href="https://eel.is/c++draft/allocator.requirements.general" target="_blank" rel="noopener"><span>[allocator.requirements.general]</span></a></h2><p><a href="https://eel.is/c++draft/allocator.requirements.general#1" target="_blank" rel="noopener"><span>1</span></a><span> The library describes a standard set of requirements for </span><em><span>allocators</span></em><span>, which are class-type objects that encapsulate the information about an allocation model. This information includes the knowledge of pointer types, the type of their difference, the type of the size of objects in this allocation model, as well as the memory allocation and deallocation primitives for it. All of the string types, containers (except </span><code>array</code><ins><span> and </span><code>inplace_vector</code></ins><span>), string buffers and string streams (</span><a href="https://eel.is/c++draft/input.output" target="_blank" rel="noopener"><span>[input.output]</span></a><span>), and match_results are parameterized in terms of allocators.</span></p><h2 id="containersgeneral" data-id="containersgeneral"><a class="anchor hidden-xs" href="#containersgeneral" title="containersgeneral"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/containers.general" target="_blank" rel="noopener"><span>[containers.general]</span></a></h2><p><span>Modify </span><a href="http://eel.is/c++draft/tab:containers.summary" target="_blank" rel="noopener"><span>[tab:containers.summary]</span></a><span>:</span></p><table>
<thead>
<tr>
<th></th>
<th><span>Subclause</span></th>
<th><span>Headers</span></th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="http://eel.is/c++draft/sequences" target="_blank" rel="noopener"><span>[sequences]</span></a></td>
<td><span>Sequence containers</span></td>
<td>&lt;array&gt;<span>, </span>&lt;deque&gt;<span>, &lt;forward_list&gt;</span><ins><code>, &lt;inplace_vector&gt;</code></ins><span>, </span>&lt;list&gt;<span>, </span>&lt;vector&gt;</td>
</tr>
</tbody>
</table><h2 id="containerreqmts-General-container-requirements" data-id="containerreqmts-General-container-requirements"><a class="anchor hidden-xs" href="#containerreqmts-General-container-requirements" title="containerreqmts-General-container-requirements"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/container.reqmts" target="_blank" rel="noopener"><span>[container.reqmts]</span></a><span> General container requirements</span></h2><ol>
<li><span>A type </span><code>X</code><span> meets the container requirements if the following types, statements, and expressions are well-formed and have the specified semantics.</span></li>
</ol><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>value_type
</code></pre><ul>
<li><span>Result: </span><code>T</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17Erasable</code><span> from </span><code>X</code><span> (see [container.alloc.reqmts], below).</span></li>
</ul><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>reference
</code></pre><ul>
<li><span>Result: </span><code>T&amp;</code></li>
</ul><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>const_reference
</code></pre><ul>
<li><span>Result: </span><code>const T&amp;</code></li>
</ul><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>iterator
</code></pre><ul>
<li><span>Result: A type that meets the forward iterator requirements ([forward.iterators]) with value type </span><code>T</code><span>. The type </span><code>X::iterator</code><span> is convertible to </span><code>X::const_iterator</code><span>.</span></li>
</ul><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>const_iterator
</code></pre><ul>
<li><span>Result: A type that meets the requirements of a constant iterator and those of a forward iterator with value type </span><code>T</code><span>.</span></li>
</ul><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>difference_type
</code></pre><ul>
<li><span>Result: A signed integer type, identical to the difference type of </span><code>X::iterator</code><span> and </span><code>X::const_iterator</code><span>.</span></li>
</ul><pre><code class="cpp hljs"><span class="token keyword">typename</span> <span class="token class-name">X</span><span class="token double-colon punctuation">::</span>size_type
</code></pre><ul>
<li><span>Result: An unsigned integer type that can represent any non-negative value of </span><code>X::difference_type</code><span>.</span></li>
</ul><pre><code class="cpp hljs">X u<span class="token punctuation">;</span>
X u <span class="token operator">=</span> <span class="token function">X</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><span>Postconditions: </span><code>u.empty()</code></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">X <span class="token function">u</span><span class="token punctuation">(</span>a<span class="token punctuation">)</span><span class="token punctuation">;</span>
X u <span class="token operator">=</span> a<span class="token punctuation">;</span>
</code></pre><ul>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17CopyInsertable</code><span> into </span><code>X</code><span> (see below).</span></li>
<li><span>Postconditions: </span><code>u == a</code></li>
<li><span>Complexity: Linear.</span></li>
</ul><pre><code class="cpp hljs">X <span class="token function">u</span><span class="token punctuation">(</span>rv<span class="token punctuation">)</span><span class="token punctuation">;</span>
X u <span class="token operator">=</span> rv<span class="token punctuation">;</span>
</code></pre><ul>
<li><span>Postconditions: </span><code>u</code><span> is equal to the value that </span><code>rv</code><span> had before this construction.</span></li>
<li><span>Complexity: Linear for array</span><ins><span> and </span><code>inplace_vector</code></ins><span> and constant for all other standard containers.</span></li>
</ul><pre><code class="cpp hljs">a <span class="token operator">=</span> rv
</code></pre><ul>
<li><span>Result: </span><code>X&amp;</code><span>.</span></li>
<li><span>Effects: All existing elements of </span><code>a</code><span> are either move assigned to or destroyed.</span></li>
<li><span>Postconditions: If </span><code>a</code><span> and </span><code>rv</code><span> do not refer to the same object, </span><code>a</code><span> is equal to the value that </span><code>rv</code><span> had before this assignment.</span></li>
<li><span>Complexity: Linear.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token operator">~</span><span class="token function">X</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Effects: Destroys every element of </span><code>a</code><span>; any memory obtained is deallocated.</span></li>
<li><span>Complexity: Linear.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>iterator</code><span>; </span><code>const_iterator</code><span> for constant </span><code>a</code><span>.</span></li>
<li><span>Returns: An iterator referring to the first element in the container.</span></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>iterator</code><span>; </span><code>const_iterator</code><span> for constant </span><code>a</code><span>.</span></li>
<li><span>Returns: An iterator which is the past-the-end value for the container.</span></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">cbegin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>const_iterator</code><span>.</span></li>
<li><span>Returns: </span><code>const_cast&lt;X const&amp;&gt;(a).begin()</code></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">cend</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>const_iterator</code><span>.</span></li>
<li><span>Returns: </span><code>const_cast&lt;X const&amp;&gt;(a).end()</code></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">i <span class="token operator">&lt;=&gt;</span> j
</code></pre><ul>
<li><span>Result: </span><code>strong_ordering</code><span>.</span></li>
<li><span>Constraints: </span><code>X::iterator</code><span> meets the random access iterator requirements.</span></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">a <span class="token operator">==</span> b
</code></pre><ul>
<li><span>Preconditions: </span><code>T</code><span> meets the </span><code>Cpp17EqualityComparable</code><span> requirements.</span></li>
<li><span>Result: Convertible to </span><code>bool</code><span>.</span></li>
<li><span>Returns: </span><code>equal(a.begin(), a.end(), b.begin(), b.end())</code><span> [Note 1: The algorithm </span><code>equal</code><span> is defined in [alg.equal]. — end note]</span></li>
<li><span>Complexity: Constant if </span><code>a.size() != b.size()</code><span>, linear otherwise.</span></li>
<li><span>Remarks: </span><code>==</code><span> is an equivalence relation.</span></li>
</ul><pre><code class="cpp hljs">a <span class="token operator">!=</span> b
</code></pre><ul>
<li><span>Effects: Equivalent to </span><code>!(a == b)</code><span>.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">swap</span><span class="token punctuation">(</span>b<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Effects: Exchanges the contents of </span><code>a</code><span> and </span><code>b</code><span>.</span></li>
<li><span>Complexity: Linear for array</span><ins><span> and </span><code>inplace_vector</code><span>,</span></ins><span> and constant for all other standard containers.</span></li>
</ul><pre><code class="cpp hljs"><span class="token function">swap</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> b<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Effects: Equivalent to </span><code>a.swap(b)</code><span>.</span></li>
</ul><pre><code class="cpp hljs">r <span class="token operator">=</span> a
</code></pre><ul>
<li><span>Result: </span><code>X&amp;</code><span>.</span></li>
<li><span>Postconditions: </span><code>r == a</code><span>.</span></li>
<li><span>Complexity: Linear.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">size</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>size_type</code><span>.</span></li>
<li><span>Returns: </span><code>distance(a.begin(), a.end())</code><span>, i.e. the number of elements in the container.</span></li>
<li><span>Complexity: Constant.</span></li>
<li><span>Remarks: The number of elements is defined by the rules of constructors, inserts, and erases.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">max_size</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>size_type</code><span>.</span></li>
<li><span>Returns: </span><code>distance(begin(), end())</code><span> for the largest possible container.</span></li>
<li><span>Complexity: Constant.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">empty</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: Convertible to </span><code>bool</code><span>.</span></li>
<li><span>Returns: </span><code>a.begin() == a.end()</code></li>
<li><span>Complexity: Constant.</span></li>
<li><span>Remarks: If the container is empty, then </span><code>a.empty()</code><span> is </span><code>true</code><span>.</span></li>
</ul><ol>
<li><span>In the expressions</span></li>
</ol><pre><code class="cpp hljs">i <span class="token operator">==</span> j
i <span class="token operator">!=</span> j
i <span class="token operator">&lt;</span> j
i <span class="token operator">&lt;=</span> j
i <span class="token operator">&gt;=</span> j
i <span class="token operator">&gt;</span> j
i <span class="token operator">&lt;=&gt;</span> j
i <span class="token operator">-</span> j
</code></pre><p><span>where </span><code>i</code><span> and </span><code>j</code><span> denote objects of a container's iterator type, either or both may be replaced by an object of the container's </span><code>const_iterator</code><span> type referring to the same element with no change in semantics.</span></p><p><span>Unless otherwise specified, all containers defined in this Clause obtain memory using an allocator (see </span><a href="https://eel.is/c++draft/allocator.requirements" target="_blank" rel="noopener"><span>[allocator.requirements]</span></a><span>).</span></p><p><span>[Note 2: In particular, containers and iterators do not store references to allocated elements other than through the allocator's pointer type, i.e., as objects of type </span><code>P</code><span> or </span><code>pointer_traits&lt;P&gt;::template rebind&lt;unspecified&gt;</code><span>, where </span><code>P</code><span> is </span><code>allocator_traits&lt;allocator_type&gt;::pointer</code><span>. — end note]</span></p><p><span>Copy constructors for these container types obtain an allocator by calling </span><code>allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction</code><span> on the allocator belonging to the container being copied. Move constructors obtain an allocator by move construction from the allocator belonging to the container being moved. Such move construction of the allocator shall not exit via an exception. All other constructors for these container types take a </span><code>const allocator_type&amp;</code><span> argument.</span></p><p><span>[Note 3: If an invocation of a constructor uses the default value of an optional allocator argument, then the allocator type must support value-initialization. — end note]</span></p><p><span>A copy of this allocator is used for any memory allocation and element construction performed, by these constructors and by all member functions, during the lifetime of each container object or until the allocator is replaced. The allocator may be replaced only via assignment or </span><code>swap()</code><span>. Allocator replacement is performed by copy assignment, move assignment, or swapping of the allocator only if</span></p><ol>
<li><code>allocator_traits&lt;allocator_type&gt;::propagate_on_container_copy_assignment::value</code><span>,</span></li>
<li><code>allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment::value</code><span>, or</span></li>
<li><code>allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value</code><br>
<span>is </span><code>true</code><span> within the implementation of the corresponding container operation. In all container types defined in this Clause, the member </span><code>get_allocator()</code><span> returns a copy of the allocator used to construct the container or, if that allocator has been replaced, a copy of the most recent replacement.</span></li>
</ol><p><span>The expression </span><code>a.swap(b)</code><span>, for containers </span><code>a</code><span> and </span><code>b</code><span> of a standard container type other than </span><code>array</code><ins><span> and </span><code>inplace_vector</code></ins><span>, shall exchange the values of </span><code>a</code><span> and </span><code>b</code><span> without invoking any move, copy, or swap operations on the individual container elements. Lvalues of any Compare, Pred, or Hash types belonging to </span><code>a</code><span> and </span><code>b</code><span> shall be swappable and shall be exchanged by calling swap as described in </span><a href="http://eel.is/c++draft/swappable.requirements" target="_blank" rel="noopener"><span>[swappable.requirements]</span></a><span>. If </span><code>allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value</code><span> is </span><code>true</code><span>, then lvalues of type </span><code>allocator_type</code><span> shall be swappable and the allocators of </span><code>a</code><span> and </span><code>b</code><span> shall also be exchanged by calling </span><code>swap</code><span> as described in </span><a href="http://eel.is/c++draft/swappable.requirements" target="_blank" rel="noopener"><span>[swappable.requirements]</span></a><span>. Otherwise, the allocators shall not be swapped, and the behavior is undefined unless </span><code>a.get_allocator() == b.get_allocator()</code><span>. Every iterator referring to an element in one container before the swap shall refer to the same element in the other container after the swap. It is unspecified whether an iterator with value </span><code>a.end()</code><span> before the swap will have value </span><code>b.end()</code><span> after the swap.</span></p><p><span>Unless otherwise specified (see [associative.reqmts.except], [unord.req.except], [deque.modifiers],</span><ins><span> [inplace.vector.modifiers] </span></ins><span>and [vector.modifiers]) all container types defined in this Clause meet the following additional requirements:</span></p><ol>
<li><span>If an exception is thrown by an insert() or emplace() function while inserting a single element, that function has no effects.</span></li>
<li><span>If an exception is thrown by a push_back(), push_front(), emplace_back(), or emplace_front() function, that function has no effects.</span></li>
<li><span>No erase(), clear(), pop_back() or pop_front() function throws an exception.</span></li>
<li><span>No copy constructor or assignment operator of a returned iterator throws an exception.</span></li>
<li><span>No swap() function throws an exception.</span></li>
<li><span>No swap() function invalidates any references, pointers, or iterators referring to the elements of the containers being swapped.</span><br>
<span>[Note 4: The end() iterator does not refer to any element, so it can be invalidated. — end note]</span></li>
</ol><h2 id="containerssequencesgeneral" data-id="containerssequencesgeneral"><a class="anchor hidden-xs" href="#containerssequencesgeneral" title="containerssequencesgeneral"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/sequences.general" target="_blank" rel="noopener"><span>[containers.sequences.general]</span></a></h2><p><span>Modify:</span></p><p><a href="http://eel.is/c++draft/sequences.general#1" target="_blank" rel="noopener"><span>1</span></a><span> The headers </span><code>&lt;array&gt;</code><span>, </span><code>&lt;deque&gt;</code><span>, </span><code>&lt;forward_list&gt;</code><span>, </span><ins><code>&lt;inplace_vector&gt;</code><span>, </span></ins><code>&lt;list&gt;</code><span>, and </span>&lt;vector&gt;<span> define class templates that meet the requirements for sequence containers.</span></p><h2 id="containerrequirementssequencereqmts" data-id="containerrequirementssequencereqmts"><a class="anchor hidden-xs" href="#containerrequirementssequencereqmts" title="containerrequirementssequencereqmts"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/sequence.reqmts" target="_blank" rel="noopener"><span>[container.requirements.sequence.reqmts]</span></a></h2><p><span>Modify:</span></p><p><a href="http://eel.is/c++draft/sequence.reqmts#1" target="_blank" rel="noopener"><span>sequence.reqmts.1</span></a><span> A sequence container organizes a finite set of objects, all of the same type, into a strictly linear arrangement. The library provides </span><del><span>four</span></del><ins><span>the following</span></ins><span> basic kinds of sequence containers: </span><code>vector</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>,</span></ins><span> </span><code>forward_list</code><span>, </span><code>list</code><span>, and </span><code>deque</code><span>. In addition, </span><code>array</code><span> is provided as a sequence container which provides limited sequence operations because it has a fixed number of elements. The library also provides container adaptors that make it easy to construct abstract data types, such as </span><code>stacks</code><span>, </span><code>queues</code><span>, </span><code>flat_maps</code><span>, </span><code>flat_multimaps</code><span>, </span><code>flat_sets</code><span>, or </span><code>flat_multisets</code><span>, out of the basic sequence container kinds (or out of other program-defined sequence containers).</span></p><p><a href="http://eel.is/c++draft/sequence.reqmts#2" target="_blank" rel="noopener"><span>sequence.reqmts.2</span></a><span> [Note </span><a href="http://eel.is/c++draft/sequence.reqmts#note-1" target="_blank" rel="noopener"><span>1</span></a><span>: The sequence containers offer the programmer different complexity trade-offs. </span><code>vector</code><span> is appropriate in most circumstances. </span><code>array</code><span> has a fixed size known during translation. </span><ins><span> </span><code>inplace_vector</code><span> has a fixed capacity known during translation.</span></ins><span> </span><code>list</code><span> or </span><code>forward_list</code><span> support frequent insertions and deletions from the middle of the sequence. </span><code>deque</code><span> supports efficient insertions and deletions taking place at the beginning or at the end of the sequence. When choosing a container, remember </span><code>vector</code><span> is best; leave a comment to explain if you choose from the rest! — end note]</span></p><p><a href="https://eel.is/c++draft/container.requirements#sequence.reqmts-5" target="_blank" rel="noopener"><span>seqeuence.reqmts.5</span></a></p><pre><code>X u(n, t);
</code></pre><ul>
<li><span>Preconditions: T is Cpp17CopyInsertable into X.</span></li>
<li><span>Effects: Constructs a sequence container with n copies of t.</span></li>
<li><span>Postconditions: distance(u.begin(), u.end()) == n is </span><code>true</code><span>.</span></li>
</ul><pre><code>X u(i, j);
</code></pre><ul>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from *i. For vector, if the iterator does not meet the Cpp17ForwardIterator requirements ([forward.iterators]), T is also Cpp17MoveInsertable into X.</span></li>
<li><span>Effects: Constructs a sequence container equal to the range [i, j). Each iterator in the range [i, j) is dereferenced exactly once.</span></li>
<li><span>Postconditions: distance(u.begin(), u.end()) == distance(i, j) is </span><code>true</code><span>.</span></li>
</ul><pre><code>X(from_range, rg)
</code></pre><ul>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from </span><code>*ranges::begin(rg)</code><span>. For vector, if R models neither </span><code>ranges::sized_range</code><span> nor </span><code>ranges::forward_range</code><span>, T is also Cpp17MoveInsertable into X.</span></li>
<li><span>Effects: Constructs a sequence container equal to the range rg. Each iterator in the range rg is dereferenced exactly once.</span></li>
<li><span>Postconditions: </span><code>distance(begin(), end()) == ranges::distance(rg)</code><span> is true.</span></li>
</ul><pre><code>X(il)
</code></pre><ul>
<li><span>Effects: Equivalent to X(il.begin(), il.end()).</span></li>
</ul><pre><code>a = il
</code></pre><ul>
<li><span>Result: </span><code>X&amp;</code><span>.</span></li>
<li><span>Preconditions: T is Cpp17CopyInsertable into X and Cpp17CopyAssignable.</span></li>
<li><span>Effects: Assigns the range [il.begin(), il.end()) into a. All existing elements of a are either assigned to or destroyed.</span></li>
<li><span>Returns: *this.</span></li>
</ul><pre><code>a.emplace(p, args)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from args. For vector and deque, T is also Cpp17MoveInsertable into X and Cpp17MoveAssignable.</span></li>
<li><span>Effects: Inserts an object of type T constructed with </span><code>std::forward&lt;Args&gt;(args)...</code><span> before p.</span><br>
<span>[Note 1: args can directly or indirectly refer to a value in a. — end note]</span></li>
<li><span>Returns: An iterator that points to the new element constructed from args into a.</span></li>
</ul><pre><code>a.insert(p, t)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: T is Cpp17CopyInsertable into X. For vector</span><ins><span>, inplace_vector</span></ins><span> and deque, T is also Cpp17CopyAssignable.</span></li>
<li><span>Effects: Inserts a copy of t before p.</span></li>
<li><span>Returns: An iterator that points to the copy of t inserted into a.</span></li>
</ul><pre><code>a.insert(p, rv)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: T is Cpp17MoveInsertable into X. For vector</span><ins><span>, inplace_vector</span></ins><span> and deque, T is also Cpp17MoveAssignable.</span></li>
<li><span>Effects: Inserts a copy of rv before p.</span></li>
<li><span>Returns: An iterator that points to the copy of rv inserted into a.</span></li>
</ul><pre><code>a.insert(p, n, t)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: T is Cpp17CopyInsertable into X and Cpp17CopyAssignable.</span></li>
<li><span>Effects: Inserts n copies of t before p.</span></li>
<li><span>Returns: An iterator that points to the copy of the first element inserted into a, or p if n == 0.</span></li>
</ul><pre><code>a.insert(p, i, j)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from *i. For vector</span><ins><span>, inplace_vector</span></ins><span> and deque, T is also Cpp17MoveInsertable into X, and T meets the Cpp17MoveConstructible, Cpp17MoveAssignable, and Cpp17Swappable ([swappable.requirements]) requirements. Neither i nor j are iterators into a.</span></li>
<li><span>Effects: Inserts copies of elements in [i, j) before p. Each iterator in the range [i, j) shall be dereferenced exactly once.</span></li>
<li><span>Returns: An iterator that points to the copy of the first element inserted into a, or p if i == j.</span></li>
</ul><pre><code>a.insert_range(p, rg)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from </span><code>*ranges::begin(rg)</code><span>. For vector</span><ins><span>, inplace_vector</span></ins><span> and deque, T is also Cpp17MoveInsertable into X, and T meets the Cpp17MoveConstructible, Cpp17MoveAssignable, and Cpp17Swappable ([swappable.requirements]) requirements. rg and a do not overlap.</span></li>
<li><span>Effects: Inserts copies of elements in rg before p. Each iterator in the range rg is dereferenced exactly once.</span></li>
<li><span>Returns: An iterator that points to the copy of the first element inserted into a, or p if rg is empty.</span></li>
</ul><pre><code>a.insert(p, il)
</code></pre><ul>
<li><span>Effects: Equivalent to a.insert(p, il.begin(), il.end()).</span></li>
</ul><pre><code>a.erase(q)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: For vector</span><ins><span>, inplace_vector</span></ins><span> and deque, T is Cpp17MoveAssignable.</span></li>
<li><span>Effects: Erases the element pointed to by q.</span></li>
<li><span>Returns: An iterator that points to the element immediately following q prior to the element being erased. If no such element exists, a.end() is returned.</span></li>
</ul><pre><code>a.erase(q1, q2)
</code></pre><ul>
<li><span>Result: iterator.</span></li>
<li><span>Preconditions: For vector</span><ins><span>, inplace_vector</span></ins><span> and deque, T is Cpp17MoveAssignable.</span></li>
<li><span>Effects: Erases the elements in the range [q1, q2).</span></li>
<li><span>Returns: An iterator that points to the element pointed to by q2 prior to any elements being erased. If no such element exists, a.end() is returned.</span></li>
</ul><pre><code>a.clear()
</code></pre><ul>
<li><span>Result: void</span></li>
<li><span>Effects: Destroys all elements in a. Invalidates all references, pointers, and iterators referring to the elements of a and may invalidate the past-the-end iterator.</span></li>
<li><span>Postconditions: a.empty() is true.</span></li>
<li><span>Complexity: Linear.</span></li>
</ul><pre><code>a.assign(i, j)
</code></pre><ul>
<li><span>Result: void</span></li>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from *i and assignable from *i. For vector, if the iterator does not meet the forward iterator requirements ([forward.iterators]), T is also Cpp17MoveInsertable into X. Neither i nor j are iterators into a.</span></li>
<li><span>Effects: Replaces elements in a with a copy of [i, j). Invalidates all references, pointers and iterators referring to the elements of a. For vector and deque, also invalidates the past-the-end iterator. Each iterator in the range [i, j) is dereferenced exactly once.</span></li>
</ul><pre><code>a.assign_range(rg)
</code></pre><ul>
<li><span>Result: void</span></li>
<li><span>Mandates: assignable_from&lt;T&amp;, ranges​::​range_reference_t</span>&lt;R&gt;<span>&gt; is modeled.</span></li>
<li><span>Preconditions: T is Cpp17EmplaceConstructible into X from </span><code>*ranges::begin(rg)</code><span>. For vector, if R models neither </span><code>ranges::sized_range</code><span> nor </span><code>ranges::forward_range</code><span>, T is also Cpp17MoveInsertable into X. rg and a do not overlap.</span></li>
<li><span>Effects: Replaces elements in a with a copy of each element in rg. Invalidates all references, pointers, and iterators referring to the elements of a. For vector and deque, also invalidates the past-the-end iterator. Each iterator in the range rg is dereferenced exactly once.</span></li>
</ul><pre><code>a.assign(il)
</code></pre><ul>
<li><span>Effects: Equivalent to a.assign(il.begin(), il.end()).</span></li>
</ul><pre><code>a.assign(n, t)
</code></pre><ul>
<li><span>Result: void</span></li>
<li><span>Preconditions: T is Cpp17CopyInsertable into X and Cpp17CopyAssignable. t is not a reference into a.</span></li>
<li><span>Effects: Replaces elements in a with n copies of t. Invalidates all references, pointers and iterators referring to the elements of a. For vector and deque, also invalidates the past-the-end iterator.</span></li>
</ul><p><a href="http://eel.is/c++draft/sequence.reqmts#69" target="_blank" rel="noopener"><span>sequence.reqmts.69</span></a><span> The following operations are provided for some types of sequence containers but not others. An implementation shall implement them so as to take amortized constant time.</span></p><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">front</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>reference</code><span>; </span><code>const_reference</code><span> for constant </span><code>a</code><span>.</span></li>
<li><span>Returns: </span><code>*a.begin()</code></li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>array</code><span>, </span><code>deque</code><span>, </span><code>forward_list</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>,</span></ins><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">back</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>reference</code><span>; </span><code>const_reference</code><span> for constant </span><code>a</code><span>.</span></li>
<li><span>Effects: Equivalent to:</span><pre><code class="cpp hljs">​​​​<span class="token keyword">auto</span> tmp <span class="token operator">=</span> a<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
​​​​<span class="token operator">--</span>tmp<span class="token punctuation">;</span>
​​​​<span class="token keyword">return</span> <span class="token operator">*</span>tmp<span class="token punctuation">;</span>
</code></pre>
</li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>array</code><span>, </span><code>deque</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>,</span></ins><span> </span><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">emplace_front</span><span class="token punctuation">(</span>args<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>reference</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17EmplaceConstructible</code><span> into </span><code>X</code><span> from </span><code>args</code><span>.</span></li>
<li><span>Effects: Prepends an object of type </span><code>T</code><span> constructed with `std::forward</span>&lt;Args&gt;<span>(args)</span><span class="smartypants">…</span><span>``.</span></li>
<li><span>Returns: `a.front()``.</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>, </span><code>forward_list</code><span>, and </span><code>list</code><span>.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">emplace_back</span><span class="token punctuation">(</span>args<span class="token punctuation">)</span>
</code></pre><p><bdi><strong><span>Drafting note</span></strong><span>: </span><code>inplace_vector</code><span> is never reallocated, so there is no need to extend the "For vector, T is also Cpp17MoveInsertable into X" to inplace_vector.</span><br>
</bdi></p><p><bdi><strong><span>Drafting note</span></strong><span>: It's okay to use </span><code>Cpp17MoveInsertable</code><span> here, even though </span><code>inplace_vector</code><span> isn’t allocator-aware. [container.alloc.reqmts.2] states: “If </span><code>X</code><span> is not allocator-aware or is a specialization of </span><code>basic_string</code><span>, the terms below [including </span><code>Cpp17MoveInsertable</code><span>] are defined as if </span><code>A</code><span> were allocator</span>&lt;T&gt;<span>”. </span></bdi></p><ul>
<li><span>Result: reference</span></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17EmplaceConstructible</code><span> into </span><code>X</code><span> from </span><code>args</code><span>. For </span><code>vector</code><span>, </span><code>T</code><span> is also </span><code>Cpp17MoveInsertable</code><span> into </span><code>X</code><span>.</span></li>
<li><span>Effects: Appends an object of type </span><code>T</code><span> constructed with </span><code>std::forward&lt;Args&gt;(args)...</code><span>.</span></li>
<li><span>Returns: `a.back()``.</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>,</span></ins><span> </span><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">push_front</span><span class="token punctuation">(</span>t<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17CopyInsertable</code><span> into </span><code>X</code><span>.</span></li>
<li><span>Effects: Prepends a copy of </span><code>t</code><span>.</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>, </span><code>forward_list</code><span>, and </span><code>list</code><span>.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">push_front</span><span class="token punctuation">(</span>rv<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17MoveInsertable</code><span> into </span><code>X</code><span>.</span></li>
<li><span>Effects: Prepends a copy of </span><code>rv</code><span>.</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>, </span><code>forward_list</code><span>, and </span><code>list</code><span>.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">prepend_range</span><span class="token punctuation">(</span>rg<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17EmplaceConstructible</code><span> into </span><code>X</code><span> from </span><code>*ranges::begin(rg)</code><span>.</span></li>
<li><span>Effects: Inserts copies of elements in </span><code>rg</code><span> before </span><code>begin()</code><span>. Each iterator in the range </span><code>rg</code><span> is dereferenced exactly once. [Note 3: The order of elements in </span><code>rg</code><span> is not reversed. — end note]</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>, </span><code>forward_list</code><span>, and </span><code>list</code><span>.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">push_back</span><span class="token punctuation">(</span>t<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: Reference</span></li>
<li><span>Returns: </span><code>a.back()</code><span>.</span></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17CopyInsertable</code><span> into </span><code>X</code><span>.</span></li>
<li><span>Effects: Appends a copy of </span><code>t</code><span>.</span></li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>deque</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>,</span></ins><span> </span><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">push_back</span><span class="token punctuation">(</span>rv<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: Reference</span></li>
<li><span>Returns: </span><code>a.back()</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17MoveInsertable</code><span> into </span><code>X</code><span>.</span></li>
<li><span>Effects: Appends a copy of </span><code>rv</code><span>.</span></li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>deque</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>, </span></ins><span> </span><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">append_range</span><span class="token punctuation">(</span>rg<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Preconditions: </span><code>T</code><span> is </span><code>Cpp17EmplaceConstructible</code><span> into </span><code>X</code><span> from </span><code>*ranges::begin(rg)</code><span>. For </span><code>vector</code><span>, </span><code>T</code><span> is also </span><code>Cpp17MoveInsertable</code><span> into </span><code>X</code><span>.</span></li>
<li><span>Effects: Inserts copies of elements in </span><code>rg</code><span> before </span><code>end()</code><span>. Each iterator in the range </span><code>rg</code><span> is dereferenced exactly once.</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>,</span><ins><code>inplace_vector</code><span>, </span></ins><span> </span><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">pop_front</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Preconditions: </span><code>a.empty()</code><span> is </span><code>false</code><span>.</span></li>
<li><span>Effects: Destroys the first element.</span></li>
<li><span>Remarks: Required for </span><code>deque</code><span>, </span><code>forward_list</code><span>, and </span><code>list</code><span>.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">pop_back</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>void</code></li>
<li><span>Preconditions: </span><code>a.empty()</code><span> is </span><code>false</code><span>.</span></li>
<li><span>Effects: Destroys the last element.</span></li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>deque</code><span>,</span><ins><code>inplace_vector</code><span>, </span></ins><span> </span><code>list</code><span>, and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">[</span>n<span class="token punctuation">]</span>
</code></pre><ul>
<li><span>Result: </span><code>reference</code><span>; </span><code>const_reference</code><span> for constant </span><code>a</code></li>
<li><span>Returns: </span><code>*(a.begin() + n)</code></li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>array</code><span>, </span><code>deque</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>, </span></ins><span> and vector.</span></li>
</ul><pre><code class="cpp hljs">a<span class="token punctuation">.</span><span class="token function">at</span><span class="token punctuation">(</span>n<span class="token punctuation">)</span>
</code></pre><ul>
<li><span>Result: </span><code>reference</code><span>; </span><code>const_reference</code><span> for constant </span><code>a</code></li>
<li><span>Returns: </span><code>*(a.begin() + n)</code></li>
<li><span>Throws: </span><code>out_of_range</code><span> if </span><code>n &gt;= a.size()</code><span>.</span></li>
<li><span>Remarks: Required for </span><code>basic_string</code><span>, </span><code>array</code><span>, </span><code>deque</code><span>,</span><ins><span> </span><code>inplace_vector</code><span>, </span></ins><span> and </span><code>vector</code><span>.</span></li>
</ul><h2 id="containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis" data-id="containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis"><a class="anchor hidden-xs" href="#containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis" title="containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.syn] Header </span><code>&lt;inplace_vector&gt;</code><span> synopsis</span></h2><p><bdi><strong><span>EDITORIAL</span></strong><span>: this synopsis goes after the corresponding one from </span><code>&lt;vector&gt;</code><span>: </span><a href="https://eel.is/c++draft/vector.syn" target="_blank" rel="noopener"><span>[vector.syn]</span></a><span>.</span></bdi></p><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token comment">// mostly freestanding</span>
<span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">include</span> <span class="token string">&lt;compare&gt;</span>              <span class="token comment">// see [compare.syn]</span></span>
<span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">include</span> <span class="token string">&lt;initializer_list&gt;</span>     <span class="token comment">// see [initializer.list.syn]</span></span>

<span class="token keyword">namespace</span> std <span class="token punctuation">{</span>

<span class="token comment">// [inplace.vector], class template inplace_vector</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> size_t N<span class="token operator">&gt;</span>
<span class="token keyword">class</span> <span class="token class-name">inplace_vector</span><span class="token punctuation">;</span> <span class="token comment">// partially freestanding</span>

<span class="token comment">// [inplace.vector.erasure], erasure</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> size_t N<span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">U</span><span class="token operator">&gt;</span>
<span class="token keyword">constexpr</span> <span class="token keyword">typename</span> <span class="token class-name">inplace_vector</span><span class="token operator">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span>size_type
  <span class="token function">erase</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token operator">&amp;</span> c<span class="token punctuation">,</span> <span class="token keyword">const</span> U<span class="token operator">&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> size_t N<span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">Predicate</span><span class="token operator">&gt;</span>
<span class="token keyword">constexpr</span> <span class="token keyword">typename</span> <span class="token class-name">inplace_vector</span><span class="token operator">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span>size_type
  <span class="token function">erase_if</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token operator">&amp;</span> c<span class="token punctuation">,</span> Predicate pred<span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token punctuation">}</span>  <span class="token comment">// namespace std</span>
</div></div></code></pre><p><bdi><strong><span>Drafting note</span></strong><span>: </span><code>erase</code><span> and </span><code>erase_if</code><span> are specified in terms of </span><code>remove</code><span> and </span><code>remove_if</code><span> which are not freestanding, and are therefore not freestanding here.</span></bdi></p><h2 id="containerssequencesinplacevector-Class-template-inplace_vector" data-id="containerssequencesinplacevector-Class-template-inplace_vector" data-original-title="" title=""><a class="anchor hidden-xs" href="#containerssequencesinplacevector-Class-template-inplace_vector" title="containerssequencesinplacevector-Class-template-inplace_vector"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector] Class template </span><code>inplace_vector</code></h2><p><bdi><strong><span>EDITORIAL</span></strong><span>: this section goes after the corresponding one from </span><code>&lt;vector&gt;</code><span>: </span><a href="https://eel.is/c++draft/vector" target="_blank" rel="noopener"><span>[vector]</span></a><span>. The sub-sections of this section are nested within it.</span></bdi></p><h3 id="containerssequencesinplacevectoroverview-Overview" data-id="containerssequencesinplacevectoroverview-Overview"><a class="anchor hidden-xs" href="#containerssequencesinplacevectoroverview-Overview" title="containerssequencesinplacevectoroverview-Overview"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.overview] Overview</span></h3><ol>
<li><ins><span>An </span><code>inplace_vector</code><span> is a contiguous container. Its capacity is fixed and its elements are stored within the </span><code>inplace_vector</code><span> object itself.</span></ins></li>
<li><ins><span>An </span><code>inplace_vector</code><span> meets all of the requirements of a container (</span><a href="http://eel.is/c++draft/container.requirements" target="_blank" rel="noopener"><span>[container.requirements]</span></a><span>), of a reversible container (</span><a href="http://eel.is/c++draft/container.rev.reqmts" target="_blank" rel="noopener"><span>[container.rev.reqmts]</span></a><span>), of a </span><a href="http://eel.is/c++draft/container.reqmts#def:container,contiguous" target="_blank" rel="noopener"><span>contiguous container</span></a><span>, and of a sequence container, including most of the optional sequence container requirements (</span><a href="http://eel.is/c++draft/sequence.reqmts" target="_blank" rel="noopener"><span>[sequence.reqmts]</span></a><span>). The exceptions are the </span><code>push_front</code><span>, </span><code>prepend_range</code><span>, </span><code>pop_front</code><span>, and </span><code>emplace_front</code><span> member functions, which are not provided. Descriptions are  provided here only for operations on </span><code>inplace_vector</code><span> that are not described in one of these tables or for operations where there is additional semantic information.</span></ins></li>
<li><bdo><span>For any </span><code>N</code><span>, if </span><code>T</code><span> is an implicit-lifetime type, then </span><code>inplace_vector&lt;T, N&gt;::iterator</code><span> and </span><code>inplace_vector&lt;T, N&gt;::const_iterator</code><span> meet the constexpr iterator requirements and </span><code>/* cond-constexpr */</code><span> through this section is replaced with </span><code>constexpr</code><span> (see Remark below).</span></bdo></li>
</ol><p><bdi><strong><span>LWG Review TODO</span></strong><span>: We need to review this last clause about constexpr. LEWG design direction is that </span><code>inplace_vector</code><span> should be "as </span><code>constexpr</code><span> as possible", i.e., it should be </span><code>constexpr</code><span> for the types for which C++26 can support </span><code>constexpr</code><span> here. That is, this clause needs to state that </span><code>constexpr</code><span> only applies to the types for which it's implementable in C++26. LWG should tell us whether this is implicit-lifetime types, trivial types, or something else, and how to word this requirement. The current proposal is to make the API conditionally constexpr.</span></bdi></p><ol start="4">
<li><ins><span>Any member function of </span><code>inplace_vector&lt;T, N&gt;</code><span> that would cause the size to exceed </span><code>N</code><span> throws an exception of type </span><code>bad_alloc</code><span>.</span></ins></li>
</ol><p><bdi><strong><span>Drafting note</span></strong><span>: this is required because </span><code>assign</code><span> and others come from the container requirements, and this extends that.</span></bdi></p><ol start="5">
<li><ins><span>Let </span><code>IV</code><span> denote a specialization of </span><code>inplace_vector&lt;T, N&gt;</code><span>. If </span><code>N</code><span> is zero, then </span><code>IV</code><span> is both trivial and empty. Otherwise:</span></ins>
<ul>
<li><ins><span>If </span><code>is_trivially_copy_constructible_v&lt;T&gt;</code><span> is </span><code>true</code><span>, then </span><code>IV</code><span> has a trivial copy constructor.</span></ins></li>
<li><ins><span>If </span><code>is_trivially_move_constructible_v&lt;T&gt;</code><span> is </span><code>true</code><span>, then </span><code>IV</code><span> has a trivial move constructor.</span></ins></li>
<li><ins><span>If </span><code>is_trivially_destructible_v&lt;T&gt;</code><span> is </span><code>true</code><span>, then:</span>
<ul>
<li><ins><code>IV</code><span> has a trivial destructor,</span></ins></li>
<li><ins><span>if </span><code>is_trivially_copy_constructible_v&lt;T&gt; &amp;&amp; is_trivially_copy_assignable_v&lt;T&gt;</code><span> is </span><code>true</code><span>, then </span><code>IV</code><span> has a trivial copy assignment operator,</span></ins></li>
<li><ins><span>if </span><code>is_trivially_move_constructible_v&lt;T&gt; &amp;&amp; is_trivially_move_assignable_v&lt;T&gt;</code><span> is </span><code>true</code><span>, then </span><code>IV</code><span> has a trivial move assignment operator.</span></ins></li>
</ul>
</ins></li>
</ul>
</li>
</ol><pre data-original-title="" title=""><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> size_t N<span class="token operator">&gt;</span>
<span class="token keyword">class</span> <span class="token class-name">inplace_vector</span> <span class="token punctuation">{</span>
<span class="token keyword">public</span><span class="token operator">:</span>
<span class="token comment">// types:</span>
<span class="token keyword">using</span> value_type             <span class="token operator">=</span> T<span class="token punctuation">;</span>
<span class="token keyword">using</span> pointer                <span class="token operator">=</span> T<span class="token operator">*</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> const_pointer          <span class="token operator">=</span> <span class="token keyword">const</span> T<span class="token operator">*</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> reference              <span class="token operator">=</span> value_type<span class="token operator">&amp;</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> const_reference        <span class="token operator">=</span> <span class="token keyword">const</span> value_type<span class="token operator">&amp;</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> size_type              <span class="token operator">=</span> size_t<span class="token punctuation">;</span>                 
<span class="token keyword">using</span> difference_type        <span class="token operator">=</span> ptrdiff_t<span class="token punctuation">;</span>             
<span class="token keyword">using</span> iterator               <span class="token operator">=</span> implementation<span class="token operator">-</span>defined<span class="token punctuation">;</span> <span class="token comment">// see [container.requirements]</span>
<span class="token keyword">using</span> const_iterator         <span class="token operator">=</span> implementation<span class="token operator">-</span>defined<span class="token punctuation">;</span> <span class="token comment">// see [container.requirements]</span>
<span class="token keyword">using</span> reverse_iterator       <span class="token operator">=</span> std<span class="token double-colon punctuation">::</span>reverse_iterator<span class="token operator">&lt;</span>iterator<span class="token operator">&gt;</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> const_reverse_iterator <span class="token operator">=</span> std<span class="token double-colon punctuation">::</span>reverse_iterator<span class="token operator">&lt;</span>const_iterator<span class="token operator">&gt;</span><span class="token punctuation">;</span>

<span class="token comment">// [containers.sequences.inplace.vector.cons], construct/copy/destroy</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">explicit</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">InputIterator</span><span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>InputIterator first<span class="token punctuation">,</span> InputIterator last<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>from_range_t<span class="token punctuation">,</span> R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span><span class="token keyword">const</span> inplace_vector<span class="token operator">&amp;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&amp;&amp;</span><span class="token punctuation">)</span>
  <span class="token keyword">noexcept</span><span class="token punctuation">(</span>N <span class="token operator">==</span> <span class="token number">0</span> <span class="token operator">||</span> is_nothrow_move_constructible_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>initializer_list<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> il<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token operator">~</span><span class="token function">inplace_vector</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> inplace_vector<span class="token operator">&amp;</span> <span class="token keyword">operator</span><span class="token operator">=</span><span class="token punctuation">(</span><span class="token keyword">const</span> inplace_vector<span class="token operator">&amp;</span> other<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> inplace_vector<span class="token operator">&amp;</span> <span class="token keyword">operator</span><span class="token operator">=</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&amp;&amp;</span> other<span class="token punctuation">)</span>
  <span class="token keyword">noexcept</span><span class="token punctuation">(</span>N <span class="token operator">==</span> <span class="token number">0</span> <span class="token operator">||</span> <span class="token punctuation">(</span>is_nothrow_move_assignable_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> <span class="token operator">&amp;&amp;</span> is_nothrow_move_constructible_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> inplace_vector<span class="token operator">&amp;</span> <span class="token keyword">operator</span><span class="token operator">=</span><span class="token punctuation">(</span>initializer_list<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">InputIterator</span><span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">assign</span><span class="token punctuation">(</span>InputIterator first<span class="token punctuation">,</span> InputIterator last<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">assign_range</span><span class="token punctuation">(</span>R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">assign</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> u<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">assign</span><span class="token punctuation">(</span>initializer_list<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> il<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>

<span class="token comment">// iterators</span>
<span class="token comment">/* cond-constexpr */</span> iterator               <span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>         <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_iterator         <span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>   <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> iterator               <span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span>           <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_iterator         <span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span>     <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reverse_iterator       <span class="token function">rbegin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>        <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reverse_iterator <span class="token function">rbegin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reverse_iterator       <span class="token function">rend</span><span class="token punctuation">(</span><span class="token punctuation">)</span>          <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reverse_iterator <span class="token function">rend</span><span class="token punctuation">(</span><span class="token punctuation">)</span>    <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>

<span class="token comment">/* cond-constexpr */</span> const_iterator         <span class="token function">cbegin</span><span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_iterator         <span class="token function">cend</span><span class="token punctuation">(</span><span class="token punctuation">)</span>    <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reverse_iterator <span class="token function">crbegin</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reverse_iterator <span class="token function">crend</span><span class="token punctuation">(</span><span class="token punctuation">)</span>   <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>

<span class="token comment">// [containers.sequences.inplace.vector.members] size/capacity</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">bool</span> <span class="token function">empty</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> size_type <span class="token function">size</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token keyword">static</span> <span class="token keyword">constexpr</span> size_type <span class="token function">max_size</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token keyword">static</span> <span class="token keyword">constexpr</span> size_type <span class="token function">capacity</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">resize</span><span class="token punctuation">(</span>size_type sz<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">resize</span><span class="token punctuation">(</span>size_type sz<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> c<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">static</span> <span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">reserve</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">static</span> <span class="token keyword">constexpr</span> <span class="token keyword">void</span> <span class="token function">shrink_to_fit</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token comment">// element access</span>
<span class="token comment">/* cond-constexpr */</span> reference       <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reference <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span> <span class="token keyword">const</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reference <span class="token function">at</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span> <span class="token keyword">const</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> reference       <span class="token function">at</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> reference       <span class="token function">front</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reference <span class="token function">front</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reference       <span class="token function">back</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> const_reference <span class="token function">back</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span><span class="token punctuation">;</span>
    
<span class="token comment">// [containers.sequences.inplace.vector.data], data access</span>
<span class="token comment">/* cond-constexpr */</span>       T<span class="token operator">*</span> <span class="token function">data</span><span class="token punctuation">(</span><span class="token punctuation">)</span>       <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">const</span> T<span class="token operator">*</span> <span class="token function">data</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>

<span class="token comment">// [containers.sequences.inplace.vector.modifiers], modifiers</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span> <span class="token comment">/* cond-constexpr */</span> reference <span class="token function">emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> reference <span class="token function">push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> reference <span class="token function">push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">append_range</span><span class="token punctuation">(</span>R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">pop_back</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> pointer <span class="token function">try_emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> pointer <span class="token function">try_push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> pointer <span class="token function">try_push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> ranges<span class="token double-colon punctuation">::</span>borrowed_iterator_t<span class="token operator">&lt;</span>R<span class="token operator">&gt;</span> <span class="token function">try_append_range</span><span class="token punctuation">(</span>R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span>
    
<span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> reference <span class="token function">unchecked_emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reference <span class="token function">unchecked_push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reference <span class="token function">unchecked_push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
    
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">emplace</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> size_type n<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">InputIterator</span><span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> InputIterator first<span class="token punctuation">,</span> InputIterator last<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert_range</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> initializer_list<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> il<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// freestanding-deleted</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">erase</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">erase</span><span class="token punctuation">(</span>const_iterator first<span class="token punctuation">,</span> const_iterator last<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">swap</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&amp;</span> x<span class="token punctuation">)</span>
  <span class="token keyword">noexcept</span><span class="token punctuation">(</span>N <span class="token operator">==</span> <span class="token number">0</span> <span class="token operator">||</span> <span class="token punctuation">(</span>is_nothrow_swappable_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> <span class="token operator">&amp;&amp;</span> is_nothrow_move_constructible_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">clear</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
    
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">friend</span> <span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">==</span><span class="token punctuation">(</span><span class="token keyword">const</span> inplace_vector<span class="token operator">&amp;</span> x<span class="token punctuation">,</span> <span class="token keyword">const</span> inplace_vector<span class="token operator">&amp;</span> y<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">friend</span> synth<span class="token operator">-</span>three<span class="token operator">-</span>way<span class="token operator">-</span>result<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span>
  <span class="token keyword">operator</span><span class="token operator">&lt;=&gt;</span><span class="token punctuation">(</span><span class="token keyword">const</span> inplace_vector<span class="token operator">&amp;</span> x<span class="token punctuation">,</span> <span class="token keyword">const</span> inplace_vector<span class="token operator">&amp;</span> y<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">friend</span> <span class="token keyword">void</span> <span class="token function">swap</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&amp;</span> x<span class="token punctuation">,</span> inplace_vector<span class="token operator">&amp;</span> y<span class="token punctuation">)</span>
  <span class="token keyword">noexcept</span><span class="token punctuation">(</span>N <span class="token operator">==</span> <span class="token number">0</span> <span class="token operator">||</span> <span class="token punctuation">(</span>is_nothrow_swappable_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> <span class="token operator">&amp;&amp;</span> is_nothrow_move_constructible_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">)</span>
  <span class="token punctuation">{</span> x<span class="token punctuation">.</span><span class="token function">swap</span><span class="token punctuation">(</span>y<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</div></div></code></pre><ul>
<li><bdo><em><span>Remarks</span></em><span>: Remarks: If </span><code>is_implicit_lifetime_v&lt;T&gt;</code><span> is true, then replace </span><code>/* cond-constexpr */</code><span> with </span><code>constexpr</code><span>.</span></bdo></li>
</ul><h3 id="containerssequencesinplacevectorcons-Constructors" data-id="containerssequencesinplacevectorcons-Constructors"><a class="anchor hidden-xs" href="#containerssequencesinplacevectorcons-Constructors" title="containerssequencesinplacevectorcons-Constructors"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.cons] Constructors</span></h3><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> <span class="token keyword">explicit</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><code>Cpp17DefaultInsertable</code><span> into </span><code>*this</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: Constructs an </span><code>inplace_vector</code><span> with </span><code>n</code><span> default-inserted elements.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Linear in </span><code>n</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><code>Cpp17CopyInsertable</code><span> into </span><code>*this</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: Constructs an </span><code>inplace_vector</code><span> with </span><code>n</code><span> copies of </span><code>value</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Linear in </span><code>n</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">InputIterator</span><span class="token operator">&gt;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>InputIterator first<span class="token punctuation">,</span> InputIterator last<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: Constructs an </span><code>inplace_vector</code><span> equal to the range [</span><code>first</code><span>, </span><code>last</code><span>).</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Linear in </span><code>distance(first, last)</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token function">inplace_vector</span><span class="token punctuation">(</span>from_range_t<span class="token punctuation">,</span> R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: Constructs an </span><code>inplace_vector</code><span> object with the elements of the range </span><code>rg</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Linear in </span><code>ranges::distance(rg)</code><span>.</span></ins></li>
</ul><h3 id="containerssequencesinplacevectorcapacity-Size-and-capacity" data-id="containerssequencesinplacevectorcapacity-Size-and-capacity"><a class="anchor hidden-xs" href="#containerssequencesinplacevectorcapacity-Size-and-capacity" title="containerssequencesinplacevectorcapacity-Size-and-capacity"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.capacity] Size and capacity</span></h3><pre><code class="cpp hljs"><span class="token keyword">static</span> <span class="token keyword">constexpr</span> size_type <span class="token function">capacity</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token keyword">static</span> <span class="token keyword">constexpr</span> size_type <span class="token function">max_size</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Returns</span></em><span>: </span><code>N</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">resize</span><span class="token punctuation">(</span>size_type sz<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><em><span>Cpp17DefaultInsertable</span></em><span> into </span><code>*this</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: If </span><code>sz &lt; size()</code><span>, erases the last </span><code>size() - sz</code><span> elements from the sequence. Otherwise, appends </span><code>sz - size()</code><span> default-inserted elements to the sequence.</span></ins></li>
<li><ins><em><span>Remark</span></em><span>: If an exception is thrown, there are no effects on </span><code>*this</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">resize</span><span class="token punctuation">(</span>size_type sz<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> c<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><em><span>Cpp17CopyInsertable</span></em><span> into </span><code>*this</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: If </span><code>sz &lt; size()</code><span>, erases the last </span><code>size() - sz</code><span> elements from the sequence. Otherwise, appends </span><code>sz - size()</code><span> copies of </span><code>c</code><span> to the sequence.</span></ins></li>
<li><ins><em><span>Remark</span></em><span>: If an exception is thrown, there are no effects on </span><code>*this</code><span>.</span></ins></li>
</ul><h3 id="containerssequencesinplacevectordata-Data" data-id="containerssequencesinplacevectordata-Data"><a class="anchor hidden-xs" href="#containerssequencesinplacevectordata-Data" title="containerssequencesinplacevectordata-Data"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.data] Data</span></h3><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span>       T<span class="token operator">*</span> <span class="token function">data</span><span class="token punctuation">(</span><span class="token punctuation">)</span>       <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">const</span> T<span class="token operator">*</span> <span class="token function">data</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Returns</span></em><span>: A pointer such that [</span><code>data()</code><span>, </span><code>data() + size()</code><span>) is a valid range. For a non-empty </span><code>inplace_vector</code><span>, </span><code>data() == addressof(front())</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Constant time.</span></ins></li>
</ul><h3 id="containerssequencesinplacevectormodifiers-Modifiers" data-id="containerssequencesinplacevectormodifiers-Modifiers"><a class="anchor hidden-xs" href="#containerssequencesinplacevectormodifiers-Modifiers" title="containerssequencesinplacevectormodifiers-Modifiers"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.modifiers] Modifiers</span></h3><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span> 
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> size_type n<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">InputIterator</span><span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> InputIterator first<span class="token punctuation">,</span> InputIterator last<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert_range</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">insert</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> initializer_list<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> il<span class="token punctuation">)</span><span class="token punctuation">;</span>
 
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span> <span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">emplace</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">,</span> Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">append_range</span><span class="token punctuation">(</span>R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><span>Let </span><em><span>n</span></em><span> be value of </span><code>size()</code><span> before this call for </span><code>append_range</code><span> overload, and </span><code>distance(begin, position)</code><span> otherwise.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Linear in the number of elements inserted plus the distance to the end of the vector.</span></ins></li>
<li><ins><em><span>Remarks</span></em><span>: If an exception is thrown other than by the copy constructor, move constructor, assignment operator, or move assignment operator of </span><code>T</code><span> or by any </span><code>InputIterator</code><span> operation there are no effects. Otherwise, if an exception is thrown, then </span><code>size()</code><span> ≥ </span><em><span>n</span></em><span> and elements in range </span><code>begin()</code><span> + [0, </span><em><span>n</span></em><span>) are not modified.</span></ins></li>
</ul><hr><pre><code class="wrap cpp hljs"><span class="token comment">/* cond-constexpr */</span> reference <span class="token function">push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reference <span class="token function">push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> reference <span class="token function">emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Returns</span></em><span>: </span><code>back()</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Constant.</span></ins></li>
<li><ins><em><span>Throws</span></em><span>: </span><code>bad_alloc</code><span> or any exception thrown by initialization of inserted element.</span></ins></li>
<li><ins><em><span>Remarks</span></em><span>: If an exception is thrown there are no effects on </span><code>*this</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> pointer <span class="token function">try_emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> pointer <span class="token function">try_push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> pointer <span class="token function">try_push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><span>Let </span><em><span>vals</span></em><span> denote a pack:</span></ins>
<ul>
<li><ins><code>std::forward&lt;Args&gt;(args)...</code><span> for the first overload,</span></ins></li>
<li><ins><code>x</code><span> for the second overload,</span></ins></li>
<li><ins><code>set::move(x)</code><span> for the third overload.</span></ins></li>
</ul>
</li>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><em><span>Cpp17EmplaceConstructible</span></em><span> into </span><code>*this</code><span> from </span><code>vals...</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: If </span><code>size() &lt; capacity()</code><span> is </span><code>true</code><span>, appends an object of type </span><code>T</code><span> direct-non-list-initialized with </span><code>vals...</code><span>. Otherwise, there are no effects.</span></ins></li>
<li><ins><em><span>Returns</span></em><span>: </span><code>nullptr</code><span> if </span><code>size() == capacity()</code><span> is </span><code>true</code><span>, otherwise </span><code>addressof(back())</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Constant.</span></ins></li>
<li><ins><em><span>Throws</span></em><span>: Nothing unless an exception is thrown by initialization of inserted element.</span></ins></li>
<li><ins><em><span>Remarks</span></em><span>: If an exception is thrown there are no effects on </span><code>*this</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span>container<span class="token operator">-</span>compatible<span class="token operator">-</span>range<span class="token operator">&lt;</span>T<span class="token operator">&gt;</span> R<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> ranges<span class="token double-colon punctuation">::</span>borrowed_iterator_t<span class="token operator">&lt;</span>R<span class="token operator">&gt;</span> <span class="token function">try_append_range</span><span class="token punctuation">(</span>R<span class="token operator">&amp;&amp;</span> rg<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><em><span>Cpp17EmplaceConstructible</span></em><span> from </span><code>*ranges::begin(rg)</code><span> into </span><code>*this</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: Appends copies of initial elements in </span><code>rg</code><span> before </span><code>end()</code><span>, until all elements are inserted or </span><code>size() == capacity()</code><span> is </span><code>true</code><span>. Each iterator in the range </span><code>rg</code><span> is dereferenced at most once.</span></ins></li>
<li><ins><em><span>Returns</span></em><span>: Iterator past last inserted element of </span><code>rg</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: Linear in the number of elements inserted.  </span></ins></li>
<li><ins><em><span>Remarks</span></em><span>: Let </span><em><span>n</span></em><span> be the value of </span><code>size()</code><span> prior to this call. If an exception is thrown after insertion of </span><em><span>k</span></em><span> elements, then </span><code>size()</code><span> equals </span><em><span>n</span></em><span> + </span><em><span>k</span></em><span>, elements in the range </span><code>begin()</code><span> + [0, </span><em><span>n</span></em><span>) are not modified, and elements in the range </span><code>begin()</code><span> + [</span><em><span>n</span></em><span>, </span><em><span>n</span></em><span> + </span><em><span>k</span></em><span>) correspond to the inserted elements.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> reference <span class="token function">unchecked_emplace_back</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is </span><code>true</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: Equivalent to: </span><code>return *try_emplace_back(std::forward&lt;Args&gt;(args)...);</code></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> reference <span class="token function">unchecked_push_back</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> reference <span class="token function">unchecked_push_back</span><span class="token punctuation">(</span>T<span class="token operator">&amp;&amp;</span> x<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is </span><code>true</code><span>.</span></ins></li>
<li><ins><em><span>Effects</span></em><span>: Equivalent to: </span><code>return *try_push_back(std::forward&lt;decltype(x)&gt;(x));</code></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">static</span> <span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">reserve</span><span class="token punctuation">(</span>size_type n<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: none.</span></ins></li>
<li><ins><em><span>Throws</span></em><span>: </span><code>bad_alloc</code><span> if </span><code>n &gt; capacity()</code><span> is </span><code>true</code><span>.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token keyword">static</span> <span class="token keyword">constexpr</span> <span class="token keyword">void</span> <span class="token function">shrink_to_fit</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: none.</span></ins></li>
</ul><hr><pre><code class="cpp hljs"><span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">erase</span><span class="token punctuation">(</span>const_iterator position<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> iterator <span class="token function">erase</span><span class="token punctuation">(</span>const_iterator first<span class="token punctuation">,</span> const_iterator last<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">/* cond-constexpr */</span> <span class="token keyword">void</span> <span class="token function">pop_back</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: Invalidates iterators and references at or after the point of the erase.</span></ins></li>
<li><ins><em><span>Throws</span></em><span>: Nothing unless an exception is thrown by the assignment operator or move assignment operator of </span><code>T</code><span>.</span></ins></li>
<li><ins><em><span>Complexity</span></em><span>: The destructor of </span><code>T</code><span> is called the number of times equal to the number of the elements erased, but the assignment operator of </span><code>T</code><span> is called the number of times equal to the number of elements after the erased elements.</span></ins></li>
</ul><h3 id="containerssequencesinplacevectorerasure-Erasure" data-id="containerssequencesinplacevectorerasure-Erasure"><a class="anchor hidden-xs" href="#containerssequencesinplacevectorerasure-Erasure" title="containerssequencesinplacevectorerasure-Erasure"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace.vector.erasure] Erasure</span></h3><hr><pre><code class="cpp hljs"><span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> size_t N<span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">U</span><span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> size_t <span class="token function">erase</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token operator">&amp;</span> c<span class="token punctuation">,</span> <span class="token keyword">const</span> U<span class="token operator">&amp;</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: Equivalent to:</span></ins></li>
</ul><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token keyword">auto</span> it <span class="token operator">=</span> <span class="token function">remove</span><span class="token punctuation">(</span>c<span class="token punctuation">.</span><span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> c<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> value<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> r <span class="token operator">=</span> <span class="token function">distance</span><span class="token punctuation">(</span>it<span class="token punctuation">,</span> c<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
c<span class="token punctuation">.</span><span class="token function">erase</span><span class="token punctuation">(</span>it<span class="token punctuation">,</span> c<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> r<span class="token punctuation">;</span>
</div></div></code></pre><hr><pre><code class="cpp hljs"><span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> size_t<span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">Predicate</span><span class="token operator">&gt;</span>
  <span class="token comment">/* cond-constexpr */</span> size_t <span class="token function">erase_if</span><span class="token punctuation">(</span>inplace_vector<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token operator">&amp;</span> c<span class="token punctuation">,</span> Predicate pred<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><ul>
<li><ins><em><span>Effects</span></em><span>: Equivalent to:</span></ins></li>
</ul><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token keyword">auto</span> it <span class="token operator">=</span> <span class="token function">remove_if</span><span class="token punctuation">(</span>c<span class="token punctuation">.</span><span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> c<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> pred<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> r <span class="token operator">=</span> <span class="token function">distance</span><span class="token punctuation">(</span>it<span class="token punctuation">,</span> c<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
c<span class="token punctuation">.</span><span class="token function">erase</span><span class="token punctuation">(</span>it<span class="token punctuation">,</span> c<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> r<span class="token punctuation">;</span>
</div></div></code></pre><h2 id="versionsyn" data-id="versionsyn"><a class="anchor hidden-xs" href="#versionsyn" title="versionsyn"><span class="octicon octicon-link"></span></a><a href="http://eel.is/c++draft/version.syn" rel="noopener" target="_blank"><span>[version.syn]</span></a></h2><p><ins><span>Add:</span></ins></p><pre><code class="cpp hljs"><span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">define</span> <span class="token macro-name">__cpp_lib_inplace_vector</span>   <span class="token expression"><span class="token number">20</span>XXXXL </span><span class="token comment">// also in &lt;inplace_vector&gt;</span></span>
</code></pre><h2 id="diffcpp23library-Compatibility" data-id="diffcpp23library-Compatibility"><a class="anchor hidden-xs" href="#diffcpp23library-Compatibility" title="diffcpp23library-Compatibility"><span class="octicon octicon-link"></span></a><a href="https://eel.is/c++draft/diff.cpp23.library" target="_blank" rel="noopener"><span>[diff.cpp23.library]</span></a><span> Compatibility</span></h2><p><span>Modify:</span></p><ul>
<li><a href="https://eel.is/c++draft/diff.cpp23.library#2" target="_blank" rel="noopener"><span>2</span></a><span> Affected subclause: </span><a href="https://eel.is/c++draft/headers" target="_blank" rel="noopener"><span>[headers]</span></a></li>
<li><span>Change: New headers.</span></li>
<li><span>Rationale: New functionality.</span></li>
<li><span>Effect on original feature: The following C++ headers are new: </span>&lt;debugging&gt;<span>, &lt;hazard_pointer&gt;,</span><ins><span> </span><code>&lt;inplace_vector&gt;</code><span>,</span></ins><span> </span>&lt;linalg&gt;<span>, </span>&lt;rcu&gt;<span>, and &lt;text_encoding&gt;. Valid C++ 2023 code that #includes headers with these names may be invalid in this revision of C++.</span></li>
</ul><h1 id="Acknowledgments" data-id="Acknowledgments"><a class="anchor hidden-xs" href="#Acknowledgments" title="Acknowledgments"><span class="octicon octicon-link"></span></a><span>Acknowledgments</span></h1><p><span>This proposal is based on Boost.Container's </span><code>boost::container::static_vector</code><span>, mainly authored by Adam Wulkiewicz, Andrew Hundt, and Ion Gaztanaga. The reference implementation is based on Howard Hinnant </span><code>std::vector</code><span> implementation in libc++ and its test-suite. The following people provided valuable feedback that influenced some aspects of this proposal: Walter Brown, Zach Laine, Rein Halbersma, Andrzej Krzemieński, Casey Carter, Tomasz Kamiński, and many others. Many thanks to Daniel Krügler for reviewing the wording.</span></p></div>
    <div class="ui-toc dropup unselectable hidden-print" style="display:none;">
        <div class="pull-right dropdown">
            <a id="tocLabel" class="ui-toc-label btn btn-default" data-toggle="dropdown" href="#" role="button" aria-haspopup="true" aria-expanded="false" title="Table of content">
                <i class="fa fa-bars"></i>
            </a>
            <ul id="ui-toc" class="ui-toc-dropdown dropdown-menu" aria-labelledby="tocLabel">
                <div class="toc"><ul class="nav">
<li><a href="#inplace_vector" title="inplace_vector">inplace_vector</a></li>
<li><a href="#Introduction" title="Introduction">Introduction</a></li>
<li><a href="#Motivation-and-Scope" title="Motivation and Scope">Motivation and Scope</a></li>
<li><a href="#Existing-practice" title="Existing practice">Existing practice</a></li>
<li><a href="#Design" title="Design">Design</a><ul class="nav">
<li><a href="#Standalone-or-a-special-case-another-type" title="Standalone or a special case another type?">Standalone or a special case another type?</a></li>
<li><a href="#Layout" title="Layout">Layout</a></li>
<li><a href="#Move-semantics" title="Move semantics">Move semantics</a></li>
<li><a href="#constexpr-support" title="constexpr support">constexpr support</a></li>
<li><a href="#Exception-Safety" title="Exception Safety">Exception Safety</a><ul class="nav">
<li><a href="#Exception-Safety-guarantees-of-Mutating-Operations" title="Exception Safety guarantees of Mutating Operations">Exception Safety guarantees of Mutating Operations</a></li>
<li><a href="#Exception-thrown-by-mutating-operations-exceeding-capacity" title="Exception thrown by mutating operations exceeding capacity">Exception thrown by mutating operations exceeding capacity</a></li>
</ul>
</li>
<li><a href="#Fallible-APIs" title="Fallible APIs">Fallible APIs</a></li>
<li><a href="#Fallible-Unchecked-APIs" title="Fallible Unchecked APIs">Fallible Unchecked APIs</a></li>
<li><a href="#Allocator-awareness" title="Allocator awareness">Allocator awareness</a></li>
<li><a href="#Iterator-invalidation" title="Iterator invalidation">Iterator invalidation</a></li>
<li><a href="#Freestanding" title="Freestanding">Freestanding</a></li>
<li><a href="#Same-or-Separate-header" title="Same or Separate header">Same or Separate header</a></li>
<li><a href="#Return-type-of-push_back" title="Return type of push_back">Return type of push_back</a></li>
<li><a href="#reserve-and-shrink_to_fit-APIs" title="reserve and shrink_to_fit APIs">reserve and shrink_to_fit APIs</a></li>
<li><a href="#Deduction-guides" title="Deduction guides">Deduction guides</a></li>
<li><a href="#Summary-of-semantic-differences-with-vector" title="Summary of semantic differences with vector">Summary of semantic differences with vector</a></li>
<li><a href="#Name" title="Name">Name</a></li>
</ul>
</li>
<li><a href="#Technical-specification" title="Technical specification">Technical specification</a><ul class="nav">
<li><a href="#libraryrequirementsorganizationheaders" title="[library.requirements.organization.headers]">[library.requirements.organization.headers]</a></li>
<li><a href="#iteratorrange-Range-access" title="[iterator.range] Range access">[iterator.range] Range access</a></li>
<li><a href="#containerallocreqmts" title="[container.alloc.reqmts]">[container.alloc.reqmts]</a></li>
<li><a href="#allocatorrequirementsgeneral" title="[allocator.requirements.general]">[allocator.requirements.general]</a></li>
<li><a href="#containersgeneral" title="[containers.general]">[containers.general]</a></li>
<li><a href="#containerreqmts-General-container-requirements" title="[container.reqmts] General container requirements">[container.reqmts] General container requirements</a></li>
<li><a href="#containerssequencesgeneral" title="[containers.sequences.general]">[containers.sequences.general]</a></li>
<li><a href="#containerrequirementssequencereqmts" title="[container.requirements.sequence.reqmts]">[container.requirements.sequence.reqmts]</a></li>
<li><a href="#containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis" title="[containers.sequences.inplace.vector.syn] Header <inplace_vector> synopsis">[containers.sequences.inplace.vector.syn] Header &lt;inplace_vector&gt; synopsis</a></li>
<li><a href="#containerssequencesinplacevector-Class-template-inplace_vector" title="[containers.sequences.inplace.vector] Class template inplace_vector">[containers.sequences.inplace.vector] Class template inplace_vector</a><ul class="nav">
<li><a href="#containerssequencesinplacevectoroverview-Overview" title="[containers.sequences.inplace.vector.overview] Overview">[containers.sequences.inplace.vector.overview] Overview</a></li>
<li><a href="#containerssequencesinplacevectorcons-Constructors" title="[containers.sequences.inplace.vector.cons] Constructors">[containers.sequences.inplace.vector.cons] Constructors</a></li>
<li><a href="#containerssequencesinplacevectorcapacity-Size-and-capacity" title="[containers.sequences.inplace.vector.capacity] Size and capacity">[containers.sequences.inplace.vector.capacity] Size and capacity</a></li>
<li><a href="#containerssequencesinplacevectordata-Data" title="[containers.sequences.inplace.vector.data] Data">[containers.sequences.inplace.vector.data] Data</a></li>
<li><a href="#containerssequencesinplacevectormodifiers-Modifiers" title="[containers.sequences.inplace.vector.modifiers] Modifiers">[containers.sequences.inplace.vector.modifiers] Modifiers</a></li>
<li><a href="#containerssequencesinplacevectorerasure-Erasure" title="[containers.sequences.inplace.vector.erasure] Erasure">[containers.sequences.inplace.vector.erasure] Erasure</a></li>
</ul>
</li>
<li><a href="#versionsyn" title="[version.syn]">[version.syn]</a></li>
<li><a href="#diffcpp23library-Compatibility" title="[diff.cpp23.library] Compatibility">[diff.cpp23.library] Compatibility</a></li>
</ul>
</li>
<li><a href="#Acknowledgments" title="Acknowledgments">Acknowledgments</a></li>
</ul>
</div><div class="toc-menu"><a class="expand-toggle" href="#">Expand all</a><a class="back-to-top" href="#">Back to top</a><a class="go-to-bottom" href="#">Go to bottom</a></div>
            </ul>
        </div>
    </div>
    <div id="ui-toc-affix" class="ui-affix-toc ui-toc-dropdown unselectable hidden-print" data-spy="affix" style="top:17px;display:none;"  >
        <div class="toc"><ul class="nav">
<li><a href="#inplace_vector" title="inplace_vector">inplace_vector</a></li>
<li><a href="#Introduction" title="Introduction">Introduction</a></li>
<li><a href="#Motivation-and-Scope" title="Motivation and Scope">Motivation and Scope</a></li>
<li><a href="#Existing-practice" title="Existing practice">Existing practice</a></li>
<li><a href="#Design" title="Design">Design</a><ul class="nav">
<li><a href="#Standalone-or-a-special-case-another-type" title="Standalone or a special case another type?">Standalone or a special case another type?</a></li>
<li><a href="#Layout" title="Layout">Layout</a></li>
<li><a href="#Move-semantics" title="Move semantics">Move semantics</a></li>
<li><a href="#constexpr-support" title="constexpr support">constexpr support</a></li>
<li><a href="#Exception-Safety" title="Exception Safety">Exception Safety</a><ul class="nav">
<li><a href="#Exception-Safety-guarantees-of-Mutating-Operations" title="Exception Safety guarantees of Mutating Operations">Exception Safety guarantees of Mutating Operations</a></li>
<li><a href="#Exception-thrown-by-mutating-operations-exceeding-capacity" title="Exception thrown by mutating operations exceeding capacity">Exception thrown by mutating operations exceeding capacity</a></li>
</ul>
</li>
<li><a href="#Fallible-APIs" title="Fallible APIs">Fallible APIs</a></li>
<li><a href="#Fallible-Unchecked-APIs" title="Fallible Unchecked APIs">Fallible Unchecked APIs</a></li>
<li><a href="#Allocator-awareness" title="Allocator awareness">Allocator awareness</a></li>
<li><a href="#Iterator-invalidation" title="Iterator invalidation">Iterator invalidation</a></li>
<li><a href="#Freestanding" title="Freestanding">Freestanding</a></li>
<li><a href="#Same-or-Separate-header" title="Same or Separate header">Same or Separate header</a></li>
<li><a href="#Return-type-of-push_back" title="Return type of push_back">Return type of push_back</a></li>
<li><a href="#reserve-and-shrink_to_fit-APIs" title="reserve and shrink_to_fit APIs">reserve and shrink_to_fit APIs</a></li>
<li><a href="#Deduction-guides" title="Deduction guides">Deduction guides</a></li>
<li><a href="#Summary-of-semantic-differences-with-vector" title="Summary of semantic differences with vector">Summary of semantic differences with vector</a></li>
<li><a href="#Name" title="Name">Name</a></li>
</ul>
</li>
<li><a href="#Technical-specification" title="Technical specification">Technical specification</a><ul class="nav">
<li><a href="#libraryrequirementsorganizationheaders" title="[library.requirements.organization.headers]">[library.requirements.organization.headers]</a></li>
<li><a href="#iteratorrange-Range-access" title="[iterator.range] Range access">[iterator.range] Range access</a></li>
<li><a href="#containerallocreqmts" title="[container.alloc.reqmts]">[container.alloc.reqmts]</a></li>
<li><a href="#allocatorrequirementsgeneral" title="[allocator.requirements.general]">[allocator.requirements.general]</a></li>
<li><a href="#containersgeneral" title="[containers.general]">[containers.general]</a></li>
<li><a href="#containerreqmts-General-container-requirements" title="[container.reqmts] General container requirements">[container.reqmts] General container requirements</a></li>
<li><a href="#containerssequencesgeneral" title="[containers.sequences.general]">[containers.sequences.general]</a></li>
<li><a href="#containerrequirementssequencereqmts" title="[container.requirements.sequence.reqmts]">[container.requirements.sequence.reqmts]</a></li>
<li><a href="#containerssequencesinplacevectorsyn-Header-ltinplace_vectorgt-synopsis" title="[containers.sequences.inplace.vector.syn] Header <inplace_vector> synopsis">[containers.sequences.inplace.vector.syn] Header &lt;inplace_vector&gt; synopsis</a></li>
<li><a href="#containerssequencesinplacevector-Class-template-inplace_vector" title="[containers.sequences.inplace.vector] Class template inplace_vector">[containers.sequences.inplace.vector] Class template inplace_vector</a><ul class="nav">
<li><a href="#containerssequencesinplacevectoroverview-Overview" title="[containers.sequences.inplace.vector.overview] Overview">[containers.sequences.inplace.vector.overview] Overview</a></li>
<li><a href="#containerssequencesinplacevectorcons-Constructors" title="[containers.sequences.inplace.vector.cons] Constructors">[containers.sequences.inplace.vector.cons] Constructors</a></li>
<li><a href="#containerssequencesinplacevectorcapacity-Size-and-capacity" title="[containers.sequences.inplace.vector.capacity] Size and capacity">[containers.sequences.inplace.vector.capacity] Size and capacity</a></li>
<li><a href="#containerssequencesinplacevectordata-Data" title="[containers.sequences.inplace.vector.data] Data">[containers.sequences.inplace.vector.data] Data</a></li>
<li><a href="#containerssequencesinplacevectormodifiers-Modifiers" title="[containers.sequences.inplace.vector.modifiers] Modifiers">[containers.sequences.inplace.vector.modifiers] Modifiers</a></li>
<li><a href="#containerssequencesinplacevectorerasure-Erasure" title="[containers.sequences.inplace.vector.erasure] Erasure">[containers.sequences.inplace.vector.erasure] Erasure</a></li>
</ul>
</li>
<li><a href="#versionsyn" title="[version.syn]">[version.syn]</a></li>
<li><a href="#diffcpp23library-Compatibility" title="[diff.cpp23.library] Compatibility">[diff.cpp23.library] Compatibility</a></li>
</ul>
</li>
<li><a href="#Acknowledgments" title="Acknowledgments">Acknowledgments</a></li>
</ul>
</div><div class="toc-menu"><a class="expand-toggle" href="#">Expand all</a><a class="back-to-top" href="#">Back to top</a><a class="go-to-bottom" href="#">Go to bottom</a></div>
    </div>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js" integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8=" crossorigin="anonymous"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha256-U5ZEeKfGNOja007MMD3YBI0A3OSZOQbeG6z2f2Y0hu8=" crossorigin="anonymous" defer></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gist-embed/2.6.0/gist-embed.min.js" integrity="sha256-KyF2D6xPIJUW5sUDSs93vWyZm+1RzIpKCexxElmxl8g=" crossorigin="anonymous" defer></script>
    <script>
        var markdown = $(".markdown-body");
        //smooth all hash trigger scrolling
        function smoothHashScroll() {
            var hashElements = $("a[href^='#']").toArray();
            for (var i = 0; i < hashElements.length; i++) {
                var element = hashElements[i];
                var $element = $(element);
                var hash = element.hash;
                if (hash) {
                    $element.on('click', function (e) {
                        // store hash
                        var hash = this.hash;
                        if ($(hash).length <= 0) return;
                        // prevent default anchor click behavior
                        e.preventDefault();
                        // animate
                        $('body, html').stop(true, true).animate({
                            scrollTop: $(hash).offset().top
                        }, 100, "linear", function () {
                            // when done, add hash to url
                            // (default click behaviour)
                            window.location.hash = hash;
                        });
                    });
                }
            }
        }

        smoothHashScroll();
        var toc = $('.ui-toc');
        var tocAffix = $('.ui-affix-toc');
        var tocDropdown = $('.ui-toc-dropdown');
        //toc
        tocDropdown.click(function (e) {
            e.stopPropagation();
        });

        var enoughForAffixToc = true;

        function generateScrollspy() {
            $(document.body).scrollspy({
                target: ''
            });
            $(document.body).scrollspy('refresh');
            if (enoughForAffixToc) {
                toc.hide();
                tocAffix.show();
            } else {
                tocAffix.hide();
                toc.show();
            }
            $(document.body).scroll();
        }

        function windowResize() {
            //toc right
            var paddingRight = parseFloat(markdown.css('padding-right'));
            var right = ($(window).width() - (markdown.offset().left + markdown.outerWidth() - paddingRight));
            toc.css('right', right + 'px');
            //affix toc left
            var newbool;
            var rightMargin = (markdown.parent().outerWidth() - markdown.outerWidth()) / 2;
            //for ipad or wider device
            if (rightMargin >= 133) {
                newbool = true;
                var affixLeftMargin = (tocAffix.outerWidth() - tocAffix.width()) / 2;
                var left = markdown.offset().left + markdown.outerWidth() - affixLeftMargin;
                tocAffix.css('left', left + 'px');
            } else {
                newbool = false;
            }
            if (newbool != enoughForAffixToc) {
                enoughForAffixToc = newbool;
                generateScrollspy();
            }
        }
        $(window).resize(function () {
            windowResize();
        });
        $(document).ready(function () {
            windowResize();
            generateScrollspy();
        });

        //remove hash
        function removeHash() {
            window.location.hash = '';
        }

        var backtotop = $('.back-to-top');
        var gotobottom = $('.go-to-bottom');

        backtotop.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            if (scrollToTop)
                scrollToTop();
            removeHash();
        });
        gotobottom.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            if (scrollToBottom)
                scrollToBottom();
            removeHash();
        });

        var toggle = $('.expand-toggle');
        var tocExpand = false;

        checkExpandToggle();
        toggle.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            tocExpand = !tocExpand;
            checkExpandToggle();
        })

        function checkExpandToggle () {
            var toc = $('.ui-toc-dropdown .toc');
            var toggle = $('.expand-toggle');
            if (!tocExpand) {
                toc.removeClass('expand');
                toggle.text('Expand all');
            } else {
                toc.addClass('expand');
                toggle.text('Collapse all');
            }
        }

        function scrollToTop() {
            $('body, html').stop(true, true).animate({
                scrollTop: 0
            }, 100, "linear");
        }

        function scrollToBottom() {
            $('body, html').stop(true, true).animate({
                scrollTop: $(document.body)[0].scrollHeight
            }, 100, "linear");
        }
    </script>
</body>

</html>
