<!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{background-color:#f7f7f7;border-radius:3px;font-size:85%;line-height:1.45;overflow:auto;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-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>p:last-child{margin-bottom: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 .alert>p:last-child,.markdown-body .alert>ul:last-child{margin-bottom:0}.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"><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>: P0843R8.</span><br>
<strong><span>Date</span></strong><span>: 2023-06-16.</span><br>
<strong><span>Authors</span></strong><span>: Gonzalo Brito Gadeschi, Timur Doumler, 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>: Timur Doumler &lt;papers _at_ timur.audio&gt;.</span><br>
<strong><span>Audience</span></strong><span>: LEWG.</span></p><style>
ins {
    color:green;
    background-color:yellow;
    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: 900px;
    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="#Exception-Safety" title="Exception Safety">Exception Safety</a></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="#Iterator-invalidation" title="Iterator invalidation">Iterator invalidation</a></li>
<li><a href="#Freestanding" title="Freestanding">Freestanding</a></li>
<li><a href="#Which-header-does-it-belong-to" title="Which header does it belong to?">Which header does it belong to?</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="#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="#containerssequencesinplace_vectorsyn-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="#containerssequencesinplace_vector-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="#containerssequencesinplace_vectoroverview-Overview" title="[containers.sequences.inplace_vector.overview] Overview">[containers.sequences.inplace_vector.overview] Overview</a></li>
<li><a href="#containerssequencesinplace_vectorcons-Constructors" title="[containers.sequences.inplace_vector.cons] Constructors">[containers.sequences.inplace_vector.cons] Constructors</a></li>
<li><a href="#containerssequencesinplace_vectorcapacity-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="#containerssequencesinplace_vectordata-Data" title="[containers.sequences.inplace_vector.data] Data">[containers.sequences.inplace_vector.data] Data</a></li>
<li><a href="#containerssequencesinplace_vectormodifiers-Modifiers" title="[containers.sequences.inplace_vector.modifiers] Modifiers">[containers.sequences.inplace_vector.modifiers] Modifiers</a></li>
<li><a href="#containerssequencesinplace_vectorerasure-Erasure" title="[containers.sequences.inplace_vector.erasure] Erasure">[containers.sequences.inplace_vector.erasure] Erasure</a></li>
<li><a href="#containerssequencesinplace_vectorspecial-Specialized-algorithms" title="[containers.sequences.inplace_vector.special] Specialized algorithms">[containers.sequences.inplace_vector.special] Specialized algorithms</a></li>
<li><a href="#containerssequenceinplace_vectorzero-Zero-sized-inplace-vector" title="[containers.sequence.inplace_vector.zero] Zero-sized inplace vector">[containers.sequence.inplace_vector.zero] Zero-sized inplace vector</a></li>
</ul>
</li>
<li><a href="#versionsyn" title="[version.syn]">[version.syn]</a></li>
<li><a href="#diffcpp03library-Compatibility" title="[diff.cpp03.library] Compatibility">[diff.cpp03.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 8</span></strong><span> Varna 2023 draft</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;<span> or &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 a modernized </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>. That is, a dynamically-resizable </span><code>vector</code><span> with compile-time fixed capacity and contiguous embedded storage in which the elements are stored within the vector object itself.</span></p><p><span>Its API closely resembles that of </span><code>std::vector&lt;T, A&gt;</code><span>. It is a contiguous container with </span><code>O(1)</code><span> insertion and removal of elements at the end (non-amortized) and worst case </span><code>O(size())</code><span> insertion and removal otherwise. Like </span><code>std::vector</code><span>, the elements are initialized on insertion and destroyed on removal. For trivial </span><code>value_type</code><span>s, the vector is fully usable inside </span><code>constexpr</code><span> functions.</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 a stack and the static memory segment are available,</span></li>
<li><span>memory allocation imposes an unacceptable performance penalty, e.g., with respect to 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><code>std::array</code><span> is not an option, e.g., if non-default constructible objects must be stored,</span></li>
<li><span>a dynamically-resizable array is required within </span><code>constexpr</code><span> functions,</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. to support </span><code>memcpy</code><span> for serialization purposes).</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>There are at least 3 widely used implementations of </span><code>inplace_vector</code><span>: </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:</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/Pv8894xx6" 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 4th template parameter, to make it become a </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 subtly differ 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, use, and makes it easy to “just change” one type on 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 HPC (such as copying one between a CPU and a GPU), serialization/deserialization, which is important for use cases like sending a vector via </span><code>MPI_Send</code><span>, etc.</span></p><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="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><ol>
<li><span>The </span><code>value_type</code><span>’s constructors/assignment/destructors/swap can potentially </span><code>throw</code><span> (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>emplace</code><span>, </span><code>inplace_vector(value_type, size)</code><span>, </span><code>inplace_vector(begin, end)</code><span>…), and</span></li>
<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><p><span>For </span><code>inplace_vector</code><span>, we choose the same semantics as for </span><code>vector</code><span>:</span></p><ol>
<li><span>When </span><code>value_type</code><span>’s operations are invoked, </span><code>inplace_vector</code><span> exception-safety guarantees depend on whether these operations throw, which is detected with </span><code>noexcept</code><span> if the API has a narrow contract.</span></li>
<li><span>Mutating operations that exceed the capacity ask “allocator embedded within the </span><code>inplace_vector</code><span>”, which has run out of space, for more memory, and therefore throw </span><code>std::bad_alloc</code><span> like </span><code>vector</code><span> APIs do (e.g. a </span><code>pmr</code><span> “stack allocator” throws </span><code>std::bad_alloc</code><span> as well). This preserves the programming model from </span><code>vector</code><span>.  </span><code>std::bad_alloc</code><span> also has the property that it never does an allocation itself.</span></li>
<li><span>Out-of-bounds unchecked access is a precondition violation.</span></li>
</ol><p><strong><span>Alternatives</span></strong><span>:</span></p><ol>
<li><span>Throw </span><code>std::bad_alloc</code><span> when the </span><code>inplace_vector</code><span> is out-of-memory:</span>
<ul>
<li><strong><span>Pros</span></strong><span>: same programming model as </span><code>vector</code><span>.</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> (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>
</code></pre><p><span>They can 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></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>
</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>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 presenece of an extra branch in </span><code>try_push_back</code><span>.</span></p><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>The </span><code>inplace_vector</code><span> APIs are not freestanding because all the insertion APIs (constructors, push back, insert, …) may throw </span><code>bad_alloc</code><span>.</span></p><p><span>If we were to only make the non-throwing APIs available in free standing, then this type would be useless in free standing.</span></p><p><span>We intend to propose making this freestanding in a different paper where we figure out how to do that.</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="Which-header-does-it-belong-to" data-id="Which-header-does-it-belong-to"><a class="anchor hidden-xs" href="#Which-header-does-it-belong-to" title="Which-header-does-it-belong-to"><span class="octicon octicon-link"></span></a><span>Which header does it belong to?</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>.</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="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" rel="noopener" target="_blank"><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><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" rel="noopener" target="_blank"><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><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>, </span><ins><code>&lt;inplace_vector&gt;</code><span>, </span></ins><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" rel="noopener" target="_blank"><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>&lt;list&gt;<span>, </span>&lt;vector&gt;<ins><code>, &lt;inplace_vector&gt;</code></ins></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>differcence_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 true.</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>
<li><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></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><code>&lt;list&gt;</code><span>, </span><ins><code>inplace_vector</code><span>, </span></ins><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="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><code>list</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">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><code>list</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">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></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><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><ins><span> and </span><code>inplace_vector</code></ins><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><code>list</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">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><code>list</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">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><code>list</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">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><ins><span> and </span><code>inplace_vector</code></ins><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><code>list</code><span>,</span><ins><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">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><code>list</code><span>,</span><ins><code>inplace_vector</code><span>, </span></ins><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="containerssequencesinplace_vectorsyn-Header-ltinplace_vectorgt-synopsis" data-id="containerssequencesinplace_vectorsyn-Header-ltinplace_vectorgt-synopsis"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectorsyn-Header-ltinplace_vectorgt-synopsis" title="containerssequencesinplace_vectorsyn-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><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>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><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 comment">// not freestanding yet</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">typename</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">// [inplace_vector.special], specialized algorithms</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">typename</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">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">&lt;</span>T<span class="token punctuation">,</span> N<span class="token operator">&gt;</span><span class="token operator">&amp;</span> x<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> y<span class="token punctuation">)</span>
    <span class="token keyword">noexcept</span><span class="token punctuation">(</span><span class="token keyword">noexcept</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 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">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><h2 id="containerssequencesinplace_vector-Class-template-inplace_vector" data-id="containerssequencesinplace_vector-Class-template-inplace_vector"><a class="anchor hidden-xs" href="#containerssequencesinplace_vector-Class-template-inplace_vector" title="containerssequencesinplace_vector-Class-template-inplace_vector"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector] Class template </span><code>inplace_vector</code></h2><h3 id="containerssequencesinplace_vectoroverview-Overview" data-id="containerssequencesinplace_vectoroverview-Overview"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectoroverview-Overview" title="containerssequencesinplace_vectoroverview-Overview"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.overview] Overview</span></h3><ol>
<li><span>A </span><code>inplace_vector</code><span> is a contiguous container that supports constant time </span><code>insert</code><span> and </span><code>erase</code><span> operations at the end; </span><code>insert</code><span> and </span><code>erase</code><span> in the middle take linear time. Its capacity is part of its type and its elements are stored within the </span><code>inplace_vector</code><span> object itself such that that if </span><code>v</code><span> is a  </span><code>inplace_vector&lt;T, N&gt;</code><span>, then it obeys the identity </span><code>&amp;v[n] == &amp;v[0] + n</code><span> for all </span><code>0 &lt;= n &lt;= v.size()</code><span>.</span></li>
<li><span>A </span><code>inplace_vector</code><span> satisfies the container requirements </span><a href="http://eel.is/c++draft/container.requirements" target="_blank" rel="noopener"><span>[container.requirements]</span></a><span> with the exception of the </span><code>swap</code><span> member function, whose complexity is linear instead of constant. It satisfies the sequence container requirements, including 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>), with the exception of the </span><code>push_front</code><span>, </span><code>pop_front</code><span>, and </span><code>emplace_front</code><span> member functions, which are not provided. It satisfies the reversible container (</span><a href="http://eel.is/c++draft/container.requirements" target="_blank" rel="noopener"><span>[container.requirements]</span></a><span>) and contiguous container (</span><a href="http://eel.is/c++draft/container.requirements.general" target="_blank" rel="noopener"><span>[container.requirements.general]</span></a><span>) requirements. 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></li>
<li><span>Class </span><code>inplace_vector</code><span> relies on the implicitly-declared special member functions </span><a href="http://eel.is/c++draft/class.default.ctor" target="_blank" rel="noopener"><span>[class.default.ctor]</span></a><span>, </span><a href="http://eel.is/c++draft/class.dtor" target="_blank" rel="noopener"><span>[class.dtor]</span></a><span>, and </span><a href="http://eel.is/c++draft/class.copy.ctor" target="_blank" rel="noopener"><span>[class.copy.ctor]</span></a><span> to conform to the container requirements table in [container.requirements]]. In addition to the requirements specified in the container requirements table, the move constructor and move assignment operator for array require that </span><code>T</code><span> be </span><code>Cpp17MoveConstructible</code><span> or </span><code>Cpp17MoveAssignable</code><span>, respectively.</span></li>
<li><span>The types </span><code>iterator</code><span> and </span><code>const_iterator</code><span> meet the constexpr iterator</span><br>
<span>requirements (</span><a href="http://eel.is/c++draft/iterator.requirements.general" target="_blank" rel="noopener"><span>[iterator.requirements.general]</span></a><span>)."</span></li>
</ol><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>
<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">typename</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 keyword">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 keyword">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 keyword">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 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 keyword">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 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> <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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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> is_nothrow_move_assignable_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 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 keyword">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 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> <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 keyword">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> const_reference u<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">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">// iterators</span>
<span class="token keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 punctuation">[</span><span class="token punctuation">[</span>nodiscard<span class="token punctuation">]</span><span class="token punctuation">]</span> <span class="token keyword">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 keyword">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 keyword">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 keyword">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 keyword">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>
<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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">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 keyword">constexpr</span> T<span class="token operator">&amp;</span> <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 keyword">constexpr</span> T<span class="token operator">&amp;</span> <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>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> <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 keyword">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 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">constexpr</span> T<span class="token operator">*</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 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">&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>
<span class="token keyword">constexpr</span> T<span class="token operator">&amp;</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 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 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> 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">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 keyword">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 keyword">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> const_reference 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 keyword">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 keyword">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 keyword">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>value_type<span class="token operator">&gt;</span> il<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">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 keyword">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 keyword">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>is_nothrow_swappable_v<span class="token operator">&lt;</span>value_type<span class="token operator">&gt;</span> <span class="token operator">&amp;&amp;</span>
           is_nothrow_move_constructible_v<span class="token operator">&lt;</span>value_type<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">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 keyword">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 keyword">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>value_type<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 keyword">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> is_nothrow_swappable_v<span class="token operator">&lt;</span>T<span class="token operator">&gt;</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><h3 id="containerssequencesinplace_vectorcons-Constructors" data-id="containerssequencesinplace_vectorcons-Constructors"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectorcons-Constructors" title="containerssequencesinplace_vectorcons-Constructors"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.cons] Constructors</span></h3><p><span>If </span><code>is_trivially_copy_constructible_v&lt;value_type&gt;</code><span> then </span><code>inplace_vector</code><span> move-constructor is trivial.</span></p><p><span>If </span><code>is_trivially_destructible_v&lt;value_type&gt;</code><span> then </span><code>inplace_vector</code><span> destructor is trivial.</span></p><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-title">inplace_vector</span><span class="hljs-params">()</span> <span class="hljs-keyword">noexcept</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Constructs an empty </span><code>inplace_vector</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-keyword">explicit</span> <span class="hljs-title">inplace_vector</span><span class="hljs-params">(size_type n)</span></span>;
</code></pre><ul>
<li><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><code>Cpp17CopyInsertable</code><span> into </span><code>*this</code><span>.</span></li>
<li><em><span>Effects</span></em><span>: Constructs a </span><code>inplace_vector</code><span> with </span><code>n</code><span> default-inserted elements.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>n</code><span>.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr inplace<span class="hljs-constructor">_vector(<span class="hljs-params">size_type</span> <span class="hljs-params">n</span>, <span class="hljs-params">const</span> <span class="hljs-params">value_type</span>&amp; <span class="hljs-params">value</span>)</span>;
</code></pre><ul>
<li><em><span>Preconditions</span></em><span>: </span><code>T</code><span> is </span><code>Cpp17CopyInsertable</code><span> into </span><code>*this</code><span>.</span></li>
<li><em><span>Effects</span></em><span>: Constructs a </span><code>inplace_vector</code><span> with </span><code>n</code><span> copies of </span><code>value</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>n</code><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-keyword">template</span> &lt;<span class="hljs-keyword">class</span> <span class="hljs-title class_">InputIterator</span>&gt;
<span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-title">inplace_vector</span><span class="hljs-params">(InputIterator first, InputIterator last)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Constructs a </span><code>inplace_vector</code><span> equal to the range </span><code>[first, last)</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Makes only </span><em><span>N</span></em><span> calls to the copy constructor of </span><code>T</code><span> (where </span><em><span>N</span></em><span> is the distance between </span><code>first</code><span> and </span><code>last</code><span>).</span></li>
</ul><hr><pre><code class="c++ hljs">template <span class="hljs-operator">&lt;</span>container<span class="hljs-operator">-</span>compatible<span class="hljs-operator">-</span>range<span class="hljs-operator">&lt;</span>T<span class="hljs-operator">&gt;</span> R<span class="hljs-operator">&gt;</span>
constexpr inplace_vector(from_range_t, R<span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span> rg);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Constructs a </span><code>inplace_vector</code><span> object with the elements of the range </span><code>rg</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Initializes exactly </span><em><span>N</span></em><span> elements from the results of dereferencing successive iterators of </span><code>rg</code><span>, where </span><em><span>N</span></em><span> is </span><code>ranges::distance(rg)</code><span>.</span></li>
</ul><h3 id="containerssequencesinplace_vectorcapacity-Size-and-capacity" data-id="containerssequencesinplace_vectorcapacity-Size-and-capacity"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectorcapacity-Size-and-capacity" title="containerssequencesinplace_vectorcapacity-Size-and-capacity"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.capacity] Size and capacity</span></h3><pre><code class="c++ hljs"><span class="hljs-title">static</span> constexpr size_<span class="hljs-keyword">type</span> capacity() noexcept
<span class="hljs-title">static</span> constexpr size_<span class="hljs-keyword">type</span> max_size() noexcept
</code></pre><ul>
<li><em><span>Returns</span></em><span>: </span><code>N</code><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-type">void</span> <span class="hljs-title">resize</span><span class="hljs-params">(size_type sz)</span></span>;
</code></pre><ul>
<li><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-constructed elements.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_default_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>sz &lt;= capacity()</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>sz</code><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-type">void</span> <span class="hljs-title">resize</span><span class="hljs-params">(size_type sz, <span class="hljs-type">const</span> value_type&amp; c)</span></span>;
</code></pre><ul>
<li><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>.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>sz &lt;= capacity()</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>sz</code><span>.</span></li>
</ul><h3 id="containerssequencesinplace_vectordata-Data" data-id="containerssequencesinplace_vectordata-Data"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectordata-Data" title="containerssequencesinplace_vectordata-Data"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.data] Data</span></h3><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span>       T* <span class="hljs-title">data</span><span class="hljs-params">()</span>       <span class="hljs-keyword">noexcept</span></span>;
<span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-type">const</span> T* <span class="hljs-title">data</span><span class="hljs-params">()</span> <span class="hljs-type">const</span> <span class="hljs-keyword">noexcept</span></span>;
</code></pre><ul>
<li><em><span>Returns</span></em><span>: A pointer such that </span><code>[data(), 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></li>
<li><em><span>Complexity</span></em><span>: Constant time.</span></li>
</ul><h3 id="containerssequencesinplace_vectormodifiers-Modifiers" data-id="containerssequencesinplace_vectormodifiers-Modifiers"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectormodifiers-Modifiers" title="containerssequencesinplace_vectormodifiers-Modifiers"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.modifiers] Modifiers</span></h3><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> iterator <span class="hljs-title">insert</span><span class="hljs-params">(const_iterator position, <span class="hljs-type">const</span> value_type&amp; x)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts </span><code>x</code><span> at </span><code>position</code><span> and invalidates all references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s copy constructor and </span><code>is_nothrow_move_constructible_v&lt;value_type&gt;</code><span> is </span><code>true</code><span> there are no effects. Otherwise, if an exception is thrown by </span><code>value_type</code><span>’s copy constructor the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> iterator <span class="hljs-title">insert</span><span class="hljs-params">(const_iterator position, size_type n, <span class="hljs-type">const</span> value_type&amp; x)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts </span><code>n</code><span> copies of </span><code>x</code><span> at </span><code>position</code><span> and invalidates all references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>n &lt;= capacity() - size()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span> and </span><code>n</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s copy constructor and </span><code>is_nothrow_move_constructible_v&lt;value_type&gt;</code><span> is </span><code>true</code><span> there are no effects. Otherwise, if an exception is thrown by </span><code>value_type</code><span>’s copy constructor the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> iterator <span class="hljs-title">insert</span><span class="hljs-params">(const_iterator position, value_type&amp;&amp; x)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts </span><code>x</code><span> at </span><code>position</code><span> and invalidates all references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_move_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s move constructor the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-keyword">template</span> &lt;<span class="hljs-keyword">typename</span> InputIterator&gt;
<span class="hljs-function"><span class="hljs-keyword">constexpr</span> iterator <span class="hljs-title">insert</span><span class="hljs-params">(const_iterator position, InputIterator first, InputIterator last)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts elements in range </span><code>[first, last)</code><span> at </span><code>position</code><span> and invalidates all references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>distance(first, last) &lt;= capacity() - size()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;value_type, decltype(*first)&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span> and </span><code>distance(first, last)</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span> constructor from </span><code>decltype(*first)</code><span> and </span><code>is_nothrow_move_constructible_v&lt;value_type&gt;</code><span> is </span><code>true</code><span> there are no effects. Otherwise, if an exception is thrown by </span><code>value_type</code><span>’s constructor from </span><code>decltype(*first)</code><span> the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> iterator <span class="hljs-title">insert</span><span class="hljs-params">(const_iterator position, initializer_list&lt;value_type&gt; il)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts elements of </span><code>il</code><span> at </span><code>position</code><span> and invalidates all references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>il.size() &lt;= capacity() - size()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;T&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span> and </span><code>il.size()</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s copy constructor and </span><code>is_nothrow_move_constructible_v&lt;T&gt;</code><span> is </span><code>true</code><span> there are no effects. Otherwise, if an exception is thrown by </span><code>value_type</code><span>’s copy constructor the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs">template <span class="hljs-operator">&lt;</span>class... Args<span class="hljs-operator">&gt;</span>
constexpr iterator emplace(const_iterator position, Args<span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>... args);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts an element constructed from </span><code>args...</code><span> at </span><code>position</code><span> and invalidates all references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;T, Args...&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>T</code><span>’s constructor from </span><code>args...</code><span> and </span><code>is_nothrow_move_constructible_v&lt;T&gt;</code><span> is </span><code>true</code><span> there are no effects. Otherwise, if an exception is thrown by </span><code>T</code><span>’s constructor from </span><code>args...</code><span> the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs">template <span class="hljs-operator">&lt;</span>class... Args<span class="hljs-operator">&gt;</span>
constexpr reference emplace_back(Args<span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>... args);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts an element constructed from </span><code>args...</code><span> at the end.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;T, Args...&gt;</code><span> is true.</span></li>
<li><em><span>Returns</span></em><span>: A reference to the added element.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>T</code><span>’s constructor from </span><code>args...</code><span> there are no effects.</span></li>
<li><em><span>Throws</span></em><span>: ‘std::bad_alloc’ if </span><code>size() &lt; capacity()</code><span> is true.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> reference <span class="hljs-title">push_back</span><span class="hljs-params">(<span class="hljs-type">const</span> T&amp; x)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts a copy of </span><code>x</code><span> at the end.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;T&gt;</code><span> is true.</span></li>
<li><em><span>Returns</span></em><span>: A reference to the added element.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s copy constructor there are no effects.</span></li>
<li><em><span>Throws</span></em><span>: ‘std::bad_alloc’ if </span><code>size() &lt; capacity()</code><span> is true.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr reference push_back(T<span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span> x);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Moves </span><code>x</code><span> to the end.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_move_constructible_v&lt;T&gt;</code><span> is true.</span></li>
<li><em><span>Returns</span></em><span>: A reference to the added element.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>T</code><span>’s move constructor there are no effects.</span></li>
<li><em><span>Throws</span></em><span>: ‘std::bad_alloc’ if </span><code>size() &lt; capacity()</code><span> is true.</span></li>
</ul><hr><pre><code class="c++ hljs">template <span class="hljs-operator">&lt;</span>class... Args<span class="hljs-operator">&gt;</span>
constexpr pointer try_emplace_back(Args<span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>... args);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: If </span><code>size() &lt; capacity()</code><span> is true, inserts an element constructed from </span><code>args...</code><span> at the end. Otherwise, there are no effect.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;value_type, Args...&gt;</code><span> is true.</span></li>
<li><em><span>Returns</span></em><span>: If an element has been inserted, returns a pointer to this element, otherwise returns </span><code>nullptr</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s constructor from </span><code>args...</code><span> there are no effects.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr pointer <span class="hljs-keyword">try</span><span class="hljs-constructor">_push_back(<span class="hljs-params">const</span> <span class="hljs-params">value_type</span>&amp; <span class="hljs-params">x</span>)</span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: If </span><code>size() &lt; capacity()</code><span> is true, inserts a copy of </span><code>x</code><span> at the end.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Returns</span></em><span>: If an element has been inserted, returns a pointer to this element, otherwise returns </span><code>nullptr</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s copy constructor there are no effects.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr pointer <span class="hljs-keyword">try</span><span class="hljs-constructor">_push_back(<span class="hljs-params">value_type</span><span class="hljs-operator">&amp;&amp;</span> <span class="hljs-params">x</span>)</span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: If </span><code>size() &lt; capacity()</code><span> is true, moves </span><code>x</code><span> to the end.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_move_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Returns</span></em><span>: If an element has been inserted, returns a pointer to this element, otherwise returns </span><code>nullptr</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s move constructor there are no effects.</span></li>
</ul><hr><pre><code class="c++ hljs">template <span class="hljs-operator">&lt;</span>class... Args<span class="hljs-operator">&gt;</span>
constexpr reference unchecked_emplace_back(Args<span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>... args);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts an element constructed from </span><code>args...</code><span> at the end.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;value_type, Args...&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s constructor from </span><code>args...</code><span> there are no effects.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr reference unchecked<span class="hljs-constructor">_push_back(<span class="hljs-params">const</span> <span class="hljs-params">value_type</span>&amp; <span class="hljs-params">x</span>)</span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Inserts a copy of </span><code>x</code><span> at the end.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_copy_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s copy constructor there are no effects.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr reference unchecked<span class="hljs-constructor">_push_back(<span class="hljs-params">value_type</span><span class="hljs-operator">&amp;&amp;</span> <span class="hljs-params">x</span>)</span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Moves </span><code>x</code><span> to the end.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>size() &lt; capacity()</code><span> is true.</span></li>
<li><em><span>Mandates</span></em><span>: </span><code>is_move_constructible_v&lt;value_type&gt;</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s move constructor there are no effects.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function">constexpr <span class="hljs-keyword">void</span> <span class="hljs-title">pop_back</span>()</span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Removes the last element of the container and destroys it.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>!empty()</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Constant.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> <span class="hljs-type">void</span> <span class="hljs-title">reserve</span><span class="hljs-params">(size_type n)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: none.</span></li>
<li><em><span>Throws</span></em><span>: </span><code>bad_alloc</code><span> if </span><code>n &gt; capacity()</code><span>.</span></li>
</ul><hr><pre><code class="c++ hljs"><span class="hljs-function">constexpr <span class="hljs-keyword">void</span> <span class="hljs-title">shrink_to_fit</span>()</span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: none.</span></li>
<li><em><span>Throws</span></em><span>: nothing.</span></li>
</ul><hr><h3 id="containerssequencesinplace_vectorerasure-Erasure" data-id="containerssequencesinplace_vectorerasure-Erasure"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectorerasure-Erasure" title="containerssequencesinplace_vectorerasure-Erasure"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.erasure] Erasure</span></h3><pre><code class="c++ hljs"><span class="hljs-function"><span class="hljs-keyword">constexpr</span> iterator <span class="hljs-title">erase</span><span class="hljs-params">(const_iterator position)</span></span>;
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Removes the element at </span><code>position</code><span>, destroys it, and invalidates references to elements after </span><code>position</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>position</code><span> in range </span><code>[begin(), end())</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s move constructor the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr iterator erase(const_iterator <span class="hljs-keyword">first</span>, const_iterator <span class="hljs-keyword">last</span>);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Removes the elements in range </span><code>[first, last)</code><span>, destroying them, and invalidating references to elements after </span><code>last</code><span>.</span></li>
<li><em><span>Preconditions</span></em><span>: </span><code>[first, last)</code><span> in range </span><code>[begin(), end())</code><span> is true.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span> and </span><code>distance(first, last)</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: If an exception is thrown by </span><code>value_type</code><span>’s move constructor the effects are </span><em><span>unspecified</span></em><span>.</span></li>
</ul><hr><pre><code class="c++ hljs">constexpr void swap(inplace_vector<span class="hljs-operator">&amp;</span> x)
  noexcept(is_nothrow_swappable_v<span class="hljs-operator">&lt;</span>value_type<span class="hljs-operator">&gt;</span> <span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>
           is_nothrow_move_constructible_v<span class="hljs-operator">&lt;</span>value_type<span class="hljs-operator">&gt;</span>);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Exchanges the contents of </span><code>*this</code><span> with </span><code>x</code><span>. All references to the elements of </span><code>*this</code><span> and </span><code>x</code><span> are invalidated.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span> and </span><code>x.size()</code><span>.</span></li>
<li><em><span>Remarks</span></em><span>: Shall not participate in overload resolution unless </span><code>is_move_constructible_v&lt;value_type&gt;</code><span> is </span><code>true</code><span> and </span><code>is_swappable_v&lt;value_type&gt;</code><span> is </span><code>true</code><span>.</span></li>
</ul><hr><pre><code class="c++ hljs">template<span class="hljs-operator">&lt;</span>class T, size_t N, class U<span class="hljs-operator">&gt;</span>
  constexpr typename inplace_vector<span class="hljs-operator">&lt;</span>T, N<span class="hljs-operator">&gt;</span>::size_type
    erase(inplace_vector<span class="hljs-operator">&lt;</span>T, N<span class="hljs-operator">&gt;</span><span class="hljs-operator">&amp;</span> c, const U<span class="hljs-operator">&amp;</span> value);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Equivalent to:</span></li>
</ul><pre><code class="c++ hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span></div><div class="code">auto it <span class="hljs-operator">=</span> remove(c.begin(), c.end(), value);
auto r <span class="hljs-operator">=</span> distance(it, c.end());
c.erase(it, c.end());
<span class="hljs-keyword">return</span> r;
</div></div></code></pre><hr><pre><code class="c++ hljs">template<span class="hljs-operator">&lt;</span>class T, size_t, class Predicate<span class="hljs-operator">&gt;</span>
  constexpr typename inplace_vector<span class="hljs-operator">&lt;</span>T, N<span class="hljs-operator">&gt;</span>::size_type
    erase_if(inplace_vector<span class="hljs-operator">&lt;</span>T, N<span class="hljs-operator">&gt;</span><span class="hljs-operator">&amp;</span> c, Predicate pred);
</code></pre><ul>
<li><em><span>Effects</span></em><span>: Equivalent to:</span></li>
</ul><pre><code class="c++ hljs">auto it <span class="hljs-operator">=</span> remove_if(c.begin(), c.end(), pred);
auto r <span class="hljs-operator">=</span> distance(it, c.end());
c.erase(it, c.end());
<span class="hljs-keyword">return</span> r;
</code></pre><h3 id="containerssequencesinplace_vectorspecial-Specialized-algorithms" data-id="containerssequencesinplace_vectorspecial-Specialized-algorithms"><a class="anchor hidden-xs" href="#containerssequencesinplace_vectorspecial-Specialized-algorithms" title="containerssequencesinplace_vectorspecial-Specialized-algorithms"><span class="octicon octicon-link"></span></a><span>[containers.sequences.inplace_vector.special] Specialized algorithms</span></h3><pre><code class="c++ hljs">template <span class="hljs-operator">&lt;</span>typename T, size_t N<span class="hljs-operator">&gt;</span>
  constexpr void swap(inplace_vector<span class="hljs-operator">&lt;</span>T, N<span class="hljs-operator">&gt;</span><span class="hljs-operator">&amp;</span> x, inplace_vector<span class="hljs-operator">&lt;</span>T, N<span class="hljs-operator">&gt;</span><span class="hljs-operator">&amp;</span> y)
    noexcept(noexcept(x.swap(y)));
</code></pre><ul>
<li><em><span>Constraints</span></em><span>: This function shall not participate in overload resolution unless </span><code>N == 0</code><span> or </span><code>is_swappable_v&lt;T&gt;</code><span> is </span><code>true</code><span>.</span></li>
<li><em><span>Effects</span></em><span>: As if by </span><code>x.swap(y)</code><span>.</span></li>
<li><em><span>Complexity</span></em><span>: Linear in </span><code>size()</code><span> and </span><code>x.size()</code><span>.</span></li>
</ul><h3 id="containerssequenceinplace_vectorzero-Zero-sized-inplace-vector" data-id="containerssequenceinplace_vectorzero-Zero-sized-inplace-vector"><a class="anchor hidden-xs" href="#containerssequenceinplace_vectorzero-Zero-sized-inplace-vector" title="containerssequenceinplace_vectorzero-Zero-sized-inplace-vector"><span class="octicon octicon-link"></span></a><span>[containers.sequence.inplace_vector.zero] Zero-sized inplace vector</span></h3><p><code>inplace_vector</code><span> shall provide support for the special case </span><code>N == 0</code><span>.</span></p><p><span>In the case that </span><code>N == 0</code><span>, </span><code>begin() == end() == </code><span> unique value. The return value of </span><code>data()</code><span> is unspecified.</span></p><p><span>The effect of calling </span><code>front()</code><span> or </span><code>back()</code><span> for zero-sized inplace vector is undefined.</span></p><p><span>Member function </span><code>swap()</code><span> shall have a non-throwing exception specification.</span></p><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" target="_blank" rel="noopener"><span>[version.syn]</span></a></h2><p><span>Add:</span></p><pre><code class="c++ hljs"><span class="hljs-meta">#<span class="hljs-keyword">define</span> __cpp_lib_inplace_vector   202306L <span class="hljs-comment">// also in &lt;inplace_vector&gt;</span></span>
</code></pre><h2 id="diffcpp03library-Compatibility" data-id="diffcpp03library-Compatibility"><a class="anchor hidden-xs" href="#diffcpp03library-Compatibility" title="diffcpp03library-Compatibility"><span class="octicon octicon-link"></span></a><a href="https://eel.is/c++draft/diff.cpp03.library" target="_blank" rel="noopener"><span>[diff.cpp03.library]</span></a><span> Compatibility</span></h2><p><span>Modify:</span></p><ul>
<li><a href="https://eel.is/c++draft/diff.cpp03.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><code>&lt;array&gt;</code><span>, </span><code>&lt;atomic&gt;</code><span>, </span><code>&lt;chrono&gt;</code><span>, </span><code>&lt;codecvt&gt;</code><span>, </span><code>&lt;condition_variable&gt;</code><span>, </span><code>&lt;forward_list&gt;</code><span>, </span><code>&lt;future&gt;</code><span>, </span><code>&lt;initializer_list&gt;</code><span>,</span><ins><code>&lt;inplace_vector&gt;</code><span>,</span></ins><span> </span><code>&lt;mutex&gt;</code><span>, </span><code>&lt;random&gt;</code><span>, </span><code>&lt;ratio&gt;</code><span>, </span><code>&lt;regex&gt;</code><span>, </span><code>&lt;scoped_allocator&gt;</code><span>, </span><code>&lt;system_error&gt;</code><span>, </span><code>&lt;thread&gt;</code><span>, </span><code>&lt;tuple&gt;</code><span>, </span><code>&lt;typeindex&gt;</code><span>, </span><code>&lt;type_traits&gt;</code><span>, </span><code>&lt;unordered_map&gt;</code><span>, and </span><code>&lt;unordered_set&gt;</code><span>. In addition the following C compatibility headers are new: </span><code>&lt;cfenv&gt;</code><span>, </span><code>&lt;cinttypes&gt;</code><span>, </span><code>&lt;cstdint&gt;</code><span>, and </span><code>&lt;cuchar&gt;</code><span>. Valid C++ 2003 code that </span><code>#includes</code><span> 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 and many others.</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="#Exception-Safety" title="Exception Safety">Exception Safety</a></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="#Iterator-invalidation" title="Iterator invalidation">Iterator invalidation</a></li>
<li><a href="#Freestanding" title="Freestanding">Freestanding</a></li>
<li><a href="#Which-header-does-it-belong-to" title="Which header does it belong to?">Which header does it belong to?</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="#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="#containerssequencesinplace_vectorsyn-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="#containerssequencesinplace_vector-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="#containerssequencesinplace_vectoroverview-Overview" title="[containers.sequences.inplace_vector.overview] Overview">[containers.sequences.inplace_vector.overview] Overview</a></li>
<li><a href="#containerssequencesinplace_vectorcons-Constructors" title="[containers.sequences.inplace_vector.cons] Constructors">[containers.sequences.inplace_vector.cons] Constructors</a></li>
<li><a href="#containerssequencesinplace_vectorcapacity-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="#containerssequencesinplace_vectordata-Data" title="[containers.sequences.inplace_vector.data] Data">[containers.sequences.inplace_vector.data] Data</a></li>
<li><a href="#containerssequencesinplace_vectormodifiers-Modifiers" title="[containers.sequences.inplace_vector.modifiers] Modifiers">[containers.sequences.inplace_vector.modifiers] Modifiers</a></li>
<li><a href="#containerssequencesinplace_vectorerasure-Erasure" title="[containers.sequences.inplace_vector.erasure] Erasure">[containers.sequences.inplace_vector.erasure] Erasure</a></li>
<li><a href="#containerssequencesinplace_vectorspecial-Specialized-algorithms" title="[containers.sequences.inplace_vector.special] Specialized algorithms">[containers.sequences.inplace_vector.special] Specialized algorithms</a></li>
<li><a href="#containerssequenceinplace_vectorzero-Zero-sized-inplace-vector" title="[containers.sequence.inplace_vector.zero] Zero-sized inplace vector">[containers.sequence.inplace_vector.zero] Zero-sized inplace vector</a></li>
</ul>
</li>
<li><a href="#versionsyn" title="[version.syn]">[version.syn]</a></li>
<li><a href="#diffcpp03library-Compatibility" title="[diff.cpp03.library] Compatibility">[diff.cpp03.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;" null null>
        <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="#Exception-Safety" title="Exception Safety">Exception Safety</a></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="#Iterator-invalidation" title="Iterator invalidation">Iterator invalidation</a></li>
<li><a href="#Freestanding" title="Freestanding">Freestanding</a></li>
<li><a href="#Which-header-does-it-belong-to" title="Which header does it belong to?">Which header does it belong to?</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="#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="#containerssequencesinplace_vectorsyn-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="#containerssequencesinplace_vector-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="#containerssequencesinplace_vectoroverview-Overview" title="[containers.sequences.inplace_vector.overview] Overview">[containers.sequences.inplace_vector.overview] Overview</a></li>
<li><a href="#containerssequencesinplace_vectorcons-Constructors" title="[containers.sequences.inplace_vector.cons] Constructors">[containers.sequences.inplace_vector.cons] Constructors</a></li>
<li><a href="#containerssequencesinplace_vectorcapacity-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="#containerssequencesinplace_vectordata-Data" title="[containers.sequences.inplace_vector.data] Data">[containers.sequences.inplace_vector.data] Data</a></li>
<li><a href="#containerssequencesinplace_vectormodifiers-Modifiers" title="[containers.sequences.inplace_vector.modifiers] Modifiers">[containers.sequences.inplace_vector.modifiers] Modifiers</a></li>
<li><a href="#containerssequencesinplace_vectorerasure-Erasure" title="[containers.sequences.inplace_vector.erasure] Erasure">[containers.sequences.inplace_vector.erasure] Erasure</a></li>
<li><a href="#containerssequencesinplace_vectorspecial-Specialized-algorithms" title="[containers.sequences.inplace_vector.special] Specialized algorithms">[containers.sequences.inplace_vector.special] Specialized algorithms</a></li>
<li><a href="#containerssequenceinplace_vectorzero-Zero-sized-inplace-vector" title="[containers.sequence.inplace_vector.zero] Zero-sized inplace vector">[containers.sequence.inplace_vector.zero] Zero-sized inplace vector</a></li>
</ul>
</li>
<li><a href="#versionsyn" title="[version.syn]">[version.syn]</a></li>
<li><a href="#diffcpp03library-Compatibility" title="[diff.cpp03.library] Compatibility">[diff.cpp03.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>
