<!doctype html><html lang="en">
 <head>
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P1072R4: basic_string::resize_default_init</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in §N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .assertion  for assertions                    (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/******************************************************************************/
/*                                   Body                                     */
/******************************************************************************/

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;               /* limit line length to 50em for readability   */
		margin: 0 auto;                /* center text within page                     */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag     */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		/* Colors */
		color: black;
		background: white top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		color: white;
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		border-color: #c00;
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 2;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
			color: black;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			background: white;
			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;
			background: white;
		}
		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		#toc-nav > a:hover,
		#toc-nav > a:focus {
			background: #f8f8f8;
		}
		#toc-nav > a:not(:hover):not(:focus) {
			color: #707070;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}

		#toc-toggle-inline {
			vertical-align: 0.05em;
			font-size: 80%;
			color: gray;
			color: hsla(203,20%,40%,.7);
			border-style: none;
			background: transparent;
			position: relative;
		}
		#toc-toggle-inline:hover:not(:active),
		#toc-toggle-inline:focus:not(:active) {
			text-shadow: 1px 1px silver;
			top: -1px;
			left: -1px;
		}

		#toc-nav :active {
			color: #C00;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;    /* Inherit the font family. */
		line-height: 1.2;        /* Keep wrapped headings compact */
		hyphens: manual;         /* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		background: transparent;
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#subtitle {
		/* #subtitle is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	 border-left: 0.5em solid #DEF;
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	  padding: .5em;
	  border: thin solid #ddd; border-radius: .5em;
	  margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	  margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	  margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	 margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	 margin-left: -2em;
	}
	dl.switch {
	 padding-left: 2em;
	}
	dl.switch > dt {
	 text-indent: -1.5em;
	 margin-top: 1em;
	}
	dl.switch > dt + dt {
	 margin-top: 0;
	}
	dl.switch > dt::before {
	 content: '\21AA';
	 padding: 0 0.5em 0 0;
	 display: inline-block;
	 width: 1em;
	 text-align: right;
	 line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: medium;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del { color: red;  text-decoration: line-through; }
	ins { color: #080; text-decoration: underline;    }

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

  /* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #C00;
		border-color: #C00;
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	/* For autogen numbers, add
	   .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,    .sidefigure img,    figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote {
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	   or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #E0CB52;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	   or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52E052;
		background: #E9FBE9;
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary::before,
	details.note > summary > .marker {
		text-transform: uppercase;
		display: block;
		color: hsl(120, 70%, 30%);
	}
	/* Add .note::before { content: "Note"; } for autogen label,
	   or use class="marker" to mark up the label in source. */

	details.note > summary {
		display: block;
		color: hsl(120, 70%, 30%);
	}
	details.note[open] > summary {
		border-bottom: 1px silver solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		background: #EEE;
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-style: none solid;
		background: #FFEECC;
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement > .marker {
		color: #B35F00;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 1em;
		right: 1em;
		bottom: 1em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #DEF;
		margin: 1.2em 0;
		border-left: 0.5em solid #8CCBF2;
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def           td.footnote {
		padding-top: 0.6em;
	}
	table.def           td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		 <table class="data"> highlights structural relationships in a table
		 when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		 Use class="complex data" for particularly complicated tables --
		 (This will draw more lines: busier, but clearer.)

		 Use class="long" on table cells with paragraph-like contents
		 (This will adjust text alignment accordingly.)
		 Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
	 vertical-align: baseline;
	 text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
		line-height: 1.1rem; /* consistent spacing */
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li             { font-weight: bold;   }
	.toc > li li          { font-weight: normal; }
	.toc > li li li       { font-size:   95%;    }
	.toc > li li li li    { font-size:   90%;    }
	.toc > li li li li .secno { font-size: 85%; }
	.toc > li li li li li { font-size:   85%;    }
	.toc > li li li li li .secno { font-size: 100%; }

	/* @supports not (display:grid) { */
		.toc > li             { margin: 1.5rem 0;    }
		.toc > li li          { margin: 0.3rem 0;    }
		.toc > li li li       { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}

		.toc li {
			clear: both;
		}

		:not(li) > .toc              { margin-left:  5rem; }
		.toc .secno                  { margin-left: -5rem; }
		.toc > li li li .secno       { margin-left: -7rem; }
		.toc > li li li li .secno    { margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc              { margin-left:  4rem; }
			.toc .secno                  { margin-left: -4rem; }
			.toc > li li li              { margin-left:  1rem; }
			.toc > li li li .secno       { margin-left: -5rem; }
			.toc > li li li li .secno    { margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
	/* } */

	@supports (display:grid) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			   comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover {
			background: rgba(75%, 75%, 75%, .25);
			border-bottom: 3px solid #054572;
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index       { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li    { margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em }
	ul.index dl    { margin-top: 0; }
	ul.index dt    { margin: .2em 0 .2em 20px;}
	ul.index dd    { margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li span {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		background: #f7f8f9;
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}

/******************************************************************************/
/*                                    Legacy                                  */
/******************************************************************************/

	/* This rule is inherited from past style sheets. No idea what it's for. */
	.hide { display: none }



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-left: calc(13px + 26.5rem - 50vw);
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-left: calc(40em - 50vw) !important;
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-left: 0 !important;
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			 * http://lea.verou.me/2012/04/background-attachment-local/
			 *
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
			            top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
			            top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }
  </style>
  <meta content="Bikeshed version 872cce6d3026423d677f3bd5837f1a1a46299a04" name="generator">
  <link href="http://wg21.link/P1072R4" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-syntax-highlighting */

.highlight:not(.idl) { background: hsl(24, 20%, 95%); }
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</style>
<style>/* style-selflinks */

.heading, .issue, .note, .example, li, dt {
    position: relative;
}
a.self-link {
    position: absolute;
    top: 0;
    left: calc(-1 * (3.5rem - 26px));
    width: calc(3.5rem - 26px);
    height: 2em;
    text-align: center;
    border: none;
    transition: opacity .2s;
    opacity: .5;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: gray;
    color: white;
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: black;
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }</style>
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: #005a9c;
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1072R4<br>basic_string::resize_default_init</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2019-06-16">2019-06-16</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="http://wg21.link/P1072R4">http://wg21.link/P1072R4</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:ckennelly@google.com">Chris Kennelly</a> (<span class="p-org org">Google</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:mzeren@vmware.com">Mark Zeren</a> (<span class="p-org org">VMware</span>)
     <dt>Audience:
     <dd>LEWG, LWG, SG16
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>Allow access to default-initialized elements of basic_string.</p>
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#mot"><span class="secno">1</span> <span class="content">Motivation</span></a>
    <li><a href="#proposal"><span class="secno">2</span> <span class="content">Proposal</span></a>
    <li><a href="#impl"><span class="secno">3</span> <span class="content">Implementation</span></a>
    <li>
     <a href="#examples"><span class="secno">4</span> <span class="content">Examples</span></a>
     <ol class="toc">
      <li><a href="#pattern"><span class="secno">4.1</span> <span class="content">Stamping a Pattern</span></a>
      <li><a href="#c"><span class="secno">4.2</span> <span class="content">Interacting with C</span></a>
     </ol>
    <li>
     <a href="#design"><span class="secno">5</span> <span class="content">Design Considerations</span></a>
     <ol class="toc">
      <li><a href="#method-vs-alternatives"><span class="secno">5.1</span> <span class="content">Method vs. Alternatives</span></a>
      <li><a href="#allocator"><span class="secno">5.2</span> <span class="content">Allocator Interaction</span></a>
      <li><a href="#bikeshed"><span class="secno">5.3</span> <span class="content">Bikeshedding</span></a>
     </ol>
    <li>
     <a href="#alternatives"><span class="secno">6</span> <span class="content">Alternatives Considered</span></a>
     <ol class="toc">
      <li><a href="#tag"><span class="secno">6.1</span> <span class="content">Tag Type</span></a>
      <li><a href="#nonlambda"><span class="secno">6.2</span> <span class="content">Non-Lambda Approach</span></a>
      <li><a href="#buffer"><span class="secno">6.3</span> <span class="content">Standalone Type: <code class="highlight"><c- n>storage_buffer</c-></code></span></a>
      <li><a href="#external"><span class="secno">6.4</span> <span class="content">Externally-Allocated Buffer Injection</span></a>
     </ol>
    <li>
     <a href="#related"><span class="secno">7</span> <span class="content">Related Work</span></a>
     <ol class="toc">
      <li><a href="#google"><span class="secno">7.1</span> <span class="content">Google</span></a>
      <li><a href="#mongodb"><span class="secno">7.2</span> <span class="content">MongoDB</span></a>
      <li><a href="#vmware"><span class="secno">7.3</span> <span class="content">VMware</span></a>
      <li><a href="#std-proposals"><span class="secno">7.4</span> <span class="content">Discussion on std-proposals</span></a>
      <li><a href="#dynamicbuffer"><span class="secno">7.5</span> <span class="content">DynamicBuffer</span></a>
      <li><a href="#p1021"><span class="secno">7.6</span> <span class="content">P1020R1</span></a>
      <li><a href="#boost"><span class="secno">7.7</span> <span class="content">Boost</span></a>
      <li><a href="#thrust"><span class="secno">7.8</span> <span class="content">Thrust</span></a>
     </ol>
    <li>
     <a href="#wording"><span class="secno">8</span> <span class="content">Wording</span></a>
     <ol class="toc">
      <li><a href="#basic.string"><span class="secno">8.1</span> <span class="content">[<strong>basic.string</strong>]</span></a>
      <li><a href="#container"><span class="secno">8.2</span> <span class="content">[<strong>container.requirements.general</strong>]</span></a>
     </ol>
    <li><a href="#questions"><span class="secno">9</span> <span class="content">Questions for LEWG</span></a>
    <li>
     <a href="#history"><span class="secno">10</span> <span class="content">History</span></a>
     <ol class="toc">
      <li><a href="#R3"><span class="secno">10.1</span> <span class="content">R3 → R4</span></a>
      <li><a href="#R2"><span class="secno">10.2</span> <span class="content">R2 → R3</span></a>
      <li><a href="#R2①"><span class="secno">10.3</span> <span class="content">R1 → R2</span></a>
      <li><a href="#R1"><span class="secno">10.4</span> <span class="content">R0 → R1</span></a>
     </ol>
    <li><a href="#acknowledgments"><span class="secno">11</span> <span class="content">Acknowledgments</span></a>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="mot"><span class="secno">1. </span><span class="content">Motivation</span><a class="self-link" href="#mot"></a></h2>
   <p>Performance sensitive code is impacted by the cost of initializing and
manipulating strings. When streaming data into a <code class="highlight"><c- n>basic_string</c-></code>, a
programmer is faced with an unhappy choice:</p>
   <ul>
    <li data-md>
     <p><strong>Pay for extra initialization</strong> — <code class="highlight"><c- n>resize</c-></code>, which zero
initializes, followed by copy.</p>
    <li data-md>
     <p><strong>Pay for extra copies</strong> — Populate a temporary buffer, copy
it to the string.</p>
    <li data-md>
     <p><strong>Pay for extra "bookkeeping"</strong> — <code class="highlight"><c- n>reserve</c-></code> followed by small
appends, each of which checks capacity and null terminates.</p>
   </ul>
   <p>The effects of these unhappy choices can all be measured at scale, yet
C++'s hallmark is to leave no room between the language (or in this
case the library) and another language.</p>
   <p>LEWGI polled on this at the <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting:</p>
   <blockquote> We should promise more committee time to <a data-link-type="biblio" href="#biblio-p1072r1">[P1072R1]</a>, knowing that our
time is scarce and this will leave less time for other work? <br><em>Unanimous consent</em> </blockquote>
   <p>LEWG at the <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting:</p>
   <blockquote>
     We want to solve this problem 
    <table>
     <tbody>
      <tr>
       <th>SF
       <th>F
       <th>N
       <th>A
       <th>SA
      <tr>
       <td>17
       <td>5
       <td>0
       <td>0
       <td>0
    </table>
    <p>Willing to solve this for string without solving it for vector</p>
    <table>
     <tbody>
      <tr>
       <th>SF
       <th>F
       <th>N
       <th>A
       <th>SA
      <tr>
       <td>6
       <td>9
       <td>2
       <td>1
       <td>0
    </table>
   </blockquote>
   <h2 class="heading settled" data-level="2" id="proposal"><span class="secno">2. </span><span class="content">Proposal</span><a class="self-link" href="#proposal"></a></h2>
   <p>This proposal addresses the problem by adding <code class="highlight"><c- n>basic_string</c-><c- o>::</c-><c- n>resize_default_init</c-></code>:</p>
   <blockquote>
    <ins>
<pre>template<typename operation>
void resize_default_init(size_type n, Operation op);
</typename></pre>
     <ol start="8">
      <li><em>Throws:</em> <code class="highlight"><c- n>out_of_range</c-></code> if <code class="highlight"><c- n>op</c-><c- p>(</c-><c- n>data</c-><c- p>(),</c-> <c- n>n</c-><c- p>)</c-> <c- o>></c-> <c- n>n</c-></code>. 
      <li>
       <em>Effects:</em> Alters the value of <code class="highlight"><c- o>*</c-><c- k>this</c-></code> as follows: 
       <ol>
        <li>— If <code class="highlight"><c- n>n</c-> <c- o>&lt;=</c-> <c- n>size</c-><c- p>()</c-></code>, erases the last <code class="highlight"><c- n>size</c-><c- p>()</c-> <c- o>-</c-> <c- n>n</c-></code> elements.
        <li>— If <code class="highlight"><c- n>n</c-> <c- o>></c-> <c- n>size</c-><c- p>()</c-></code>, appends <code class="highlight"><c- n>n</c-> <c- o>-</c-> <c- n>size</c-><c- p>()</c-></code> default-initialized
         elements.
       </ol>
        Invokes <code class="highlight"><c- n>erase</c-><c- p>(</c-><c- n>op</c-><c- p>(</c-><c- n>data</c-><c- p>(),</c-> <c- n>n</c-><c- p>))</c-></code>. 
      <li><em>Remarks:</em> Let <code class="highlight"><c- n>m</c-> <c- o>=</c-> <c- n>op</c-><c- p>(</c-><c- n>data</c-><c- p>(),</c-> <c- n>n</c-><c- p>)</c-></code>. <code class="highlight"><c- n>op</c-></code> shall replace
    ([<strong>expr.ass</strong>]) values in the range <code class="highlight"><c- p>[</c-><c- n>data</c-><c- p>(),</c-> <c- n>data</c-><c- p>()</c-><c- o>+</c-><c- n>m</c-><c- p>)</c-></code>. 
     </ol>
    </ins>
   </blockquote>
   <p>In order to enable <code class="highlight"><c- n>resize_default_init</c-></code>, this proposal makes it
implementation-defined whether <code class="highlight"><c- n>basic_string</c-></code> uses <code class="highlight"><c- n>allocator_traits</c-><c- o>::</c-><c- n>construct</c-></code> and <code class="highlight"><c- n>allocator_traits</c-><c- o>::</c-><c- n>destroy</c-></code> to
construct and destroy the "char-like objects" that it controls. See <a href="#allocator">§ 5.2 Allocator Interaction</a> and <a href="#wording">§ 8 Wording</a> below for more details.</p>
   <h2 class="heading settled" data-level="3" id="impl"><span class="secno">3. </span><span class="content">Implementation</span><a class="self-link" href="#impl"></a></h2>
   <p><code class="highlight"><c- n>libc</c-><c- o>++</c-></code> includes a private implementation of this proposal (based on an
earlier revision) and uses it to avoid a dynamic allocation in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>filesystem</c-></code> <a data-link-type="biblio" href="#biblio-libc">[LIBC++]</a>.</p>
   <h2 class="heading settled" data-level="4" id="examples"><span class="secno">4. </span><span class="content">Examples</span><a class="self-link" href="#examples"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="pattern"><span class="secno">4.1. </span><span class="content">Stamping a Pattern</span><a class="self-link" href="#pattern"></a></h3>
   <p>Consider writing a pattern several times into a string:</p>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>GeneratePattern</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>pattern</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>count</c-><c- p>)</c-> <c- p>{</c->
   <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>ret</c-><c- p>;</c->

   <c- n>ret</c-><c- p>.</c-><c- n>reserve</c-><c- p>(</c-><c- n>pattern</c-><c- p>.</c-><c- n>size</c-><c- p>()</c-> <c- o>*</c-> <c- n>count</c-><c- p>);</c->
   <c- k>for</c-> <c- p>(</c-><c- b>size_t</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>;</c-> <c- n>i</c-><c- o>++</c-><c- p>)</c-> <c- p>{</c->
     <c- c1>// SUB-OPTIMAL:</c->
     <c- c1>// * Writes 'count' nulls</c->
     <c- c1>// * Updates size and checks for potential resize 'count' times</c->
     <c- n>ret</c-><c- p>.</c-><c- n>append</c-><c- p>(</c-><c- n>pattern</c-><c- p>);</c->
   <c- p>}</c->

   <c- k>return</c-> <c- n>ret</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>Alternatively, we could adjust the output string’s size to its final size,
avoiding the bookkeeping in <code class="highlight"><c- n>append</c-></code> at the cost of extra initialization:</p>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>GeneratePattern</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>pattern</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>count</c-><c- p>)</c-> <c- p>{</c->
   <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>ret</c-><c- p>;</c->

   <c- k>const</c-> <c- k>auto</c-> <c- n>step</c-> <c- o>=</c-> <c- n>pattern</c-><c- p>.</c-><c- n>size</c-><c- p>();</c->
   <c- c1>// SUB-OPTIMAL: We memset step*count bytes only to overwrite them.</c->
   <c- n>ret</c-><c- p>.</c-><c- n>resize</c-><c- p>(</c-><c- n>step</c-> <c- o>*</c-> <c- n>count</c-><c- p>);</c->
   <c- k>for</c-> <c- p>(</c-><c- b>size_t</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>;</c-> <c- n>i</c-><c- o>++</c-><c- p>)</c-> <c- p>{</c->
     <c- c1>// GOOD: No bookkeeping</c->
     <c- n>memcpy</c-><c- p>(</c-><c- n>ret</c-><c- p>.</c-><c- n>data</c-><c- p>()</c-> <c- o>+</c-> <c- n>i</c-> <c- o>*</c-> <c- n>step</c-><c- p>,</c-> <c- n>pattern</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>step</c-><c- p>);</c->
   <c- p>}</c->

   <c- k>return</c-> <c- n>ret</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>With this proposal:</p>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>GeneratePattern</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>pattern</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>count</c-><c- p>)</c-> <c- p>{</c->
   <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>ret</c-><c- p>;</c->

   <c- k>const</c-> <c- k>auto</c-> <c- n>step</c-> <c- o>=</c-> <c- n>pattern</c-><c- p>.</c-><c- n>size</c-><c- p>();</c->
   <c- c1>// GOOD: No initialization</c->
   <c- n>ret</c-><c- p>.</c-><c- n>resize_default_init</c-><c- p>(</c-><c- n>step</c-> <c- o>*</c-> <c- n>count</c-><c- p>,</c-> <c- p>[</c-><c- o>&amp;</c-><c- p>](</c-><c- b>char</c-><c- o>*</c-> <c- n>buf</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>n</c-><c- p>)</c-> <c- p>{</c->
       <c- k>for</c-> <c- p>(</c-><c- b>size_t</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>;</c-> <c- n>i</c-><c- o>++</c-><c- p>)</c-> <c- p>{</c->
         <c- c1>// GOOD: No bookkeeping</c->
         <c- n>memcpy</c-><c- p>(</c-><c- n>buf</c-> <c- o>+</c-> <c- n>i</c-> <c- o>*</c-> <c- n>step</c-><c- p>,</c-> <c- n>pattern</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>step</c-><c- p>);</c->
       <c- p>}</c->
   <c- p>}</c->

   <c- k>return</c-> <c- n>ret</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <h3 class="heading settled" data-level="4.2" id="c"><span class="secno">4.2. </span><span class="content">Interacting with C</span><a class="self-link" href="#c"></a></h3>
   <p>Consider wrapping a C API while working in terms of C++'s <code class="highlight"><c- n>basic_string</c-></code> vocabulary.  We <em>anticipate</em> over-allocating, as computation of the <em>length</em> of
the data is done simultaneously with the computation of the <em>contents</em>.</p>
<pre class="highlight"><c- k>extern</c-> <c- s>"C"</c-> <c- p>{</c->
  <c- b>int</c-> <c- n>compress</c-><c- p>(</c-><c- b>void</c-><c- o>*</c-> <c- n>out</c-><c- p>,</c-> <c- b>size_t</c-><c- o>*</c-> <c- n>out_size</c-><c- p>,</c-> <c- k>const</c-> <c- b>void</c-><c- o>*</c-> <c- n>in</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>in_size</c-><c- p>);</c->
  <c- b>size_t</c-> <c- nf>compressBound</c-><c- p>(</c-><c- b>size_t</c-> <c- n>bound</c-><c- p>);</c->
<c- p>}</c->

<c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>CompressWrapper</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>input</c-><c- p>)</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>compressed</c-><c- p>;</c->
    <c- c1>// Compute upper limit of compressed input.</c->
    <c- b>size_t</c-> <c- n>size</c-> <c- o>=</c-> <c- n>compressBound</c-><c- p>(</c-><c- n>input</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->

    <c- c1>// SUB-OPTIMAL: Extra initialization</c->
    <c- n>compressed</c-><c- p>.</c-><c- n>resize</c-><c- p>(</c-><c- n>size</c-><c- p>);</c->
    <c- b>int</c-> <c- n>ret</c-> <c- o>=</c-> <c- n>compress</c-><c- p>(</c-><c- o>&amp;*</c-><c- n>compressed</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- o>&amp;</c-><c- n>size</c-><c- p>,</c-> <c- n>input</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>input</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->
    <c- k>if</c-> <c- p>(</c-><c- n>ret</c-> <c- o>!=</c-> <c- n>OK</c-><c- p>)</c-> <c- p>{</c->
      <c- k>throw</c-> <c- p>...</c-><c- n>some</c-> <c- n>error</c-><c- p>...</c->
    <c- p>}</c->

    <c- c1>// Set actual size.</c->
    <c- n>compressed</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>size</c-><c- p>);</c->
    <c- k>return</c-> <c- n>compressed</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>With this proposal:</p>
<pre class="highlight"><c- k>extern</c-> <c- s>"C"</c-> <c- p>{</c->
  <c- b>int</c-> <c- n>compress</c-><c- p>(</c-><c- b>void</c-><c- o>*</c-> <c- n>out</c-><c- p>,</c-> <c- b>size_t</c-><c- o>*</c-> <c- n>out_size</c-><c- p>,</c-> <c- k>const</c-> <c- b>void</c-><c- o>*</c-> <c- n>in</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>in_size</c-><c- p>);</c->
  <c- b>size_t</c-> <c- nf>compressBound</c-><c- p>(</c-><c- b>size_t</c-> <c- n>bound</c-><c- p>);</c->
<c- p>}</c->

<c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>CompressWrapper</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>input</c-><c- p>)</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>compressed</c-><c- p>;</c->
    <c- c1>// Compute upper limit of compressed input.</c->
    <c- b>size_t</c-> <c- n>size</c-> <c- o>=</c-> <c- n>compressBound</c-><c- p>(</c-><c- n>input</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->

    <c- c1>// GOOD: No initialization</c->
    <c- n>compressed</c-><c- p>.</c-><c- n>resize_default_init</c-><c- p>(</c-><c- n>size</c-><c- p>,</c-> <c- p>[</c-><c- o>&amp;</c-><c- p>](</c-><c- b>char</c-><c- o>*</c-> <c- n>buf</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>n</c-><c- p>)</c-> <c- p>{</c->
        <c- b>int</c-> <c- n>ret</c-> <c- o>=</c-> <c- n>compress</c-><c- p>(</c-><c- n>buf</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>size</c-><c- p>,</c-> <c- n>input</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>input</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->
        <c- k>if</c-> <c- p>(</c-><c- n>ret</c-> <c- o>!=</c-> <c- n>OK</c-><c- p>)</c-> <c- p>{</c->
          <c- k>throw</c-> <c- p>...</c-><c- n>some</c-> <c- n>error</c-><c- p>...</c->
        <c- p>}</c->
        <c- k>return</c-> <c- n>n</c-><c- p>;</c->
    <c- p>}</c->
    <c- k>return</c-> <c- n>compressed</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <h2 class="heading settled" data-level="5" id="design"><span class="secno">5. </span><span class="content">Design Considerations</span><a class="self-link" href="#design"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="method-vs-alternatives"><span class="secno">5.1. </span><span class="content">Method vs. Alternatives</span><a class="self-link" href="#method-vs-alternatives"></a></h3>
   <p><code class="highlight"><c- n>resize_default_init</c-></code> exposes users to UB if they read indeterminate
([<strong>basic.indet</strong>] (6.6.4)) values in the string buffer passed to <code class="highlight"><c- n>op</c-></code>. Despite
this foot-gun, <code class="highlight"><c- n>resize_default_init</c-></code> is appealing because:</p>
   <ul>
    <li data-md>
     <p>Uninitialized buffers are not uncommon in C++. See for example <code class="highlight"><c- k>new</c-> <c- n>T</c-><c- p>[</c-><c- mi>20</c-><c- p>]</c-></code> or the recently adopted <code class="highlight"><c- n>make_unique_default_init</c-></code>.</p>
    <li data-md>
     <p>Dynamic analyzers like Memory Sanitizer <a data-link-type="biblio" href="#biblio-msan">[MSan]</a> and Valgrind <a data-link-type="biblio" href="#biblio-valgrind">[Valgrind]</a> can catch uninitialized reads.</p>
   </ul>
   <p>During the <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting LEWG expressed a preference for
implementing this functionality as a new method on <code class="highlight"><c- n>basic_string</c-></code> (as
proposed in <a data-link-type="biblio" href="#biblio-p1072r0">[P1072R0]</a>) rather than a standalone "storage buffer"
type (one option in <a data-link-type="biblio" href="#biblio-p1072r1">[P1072R1]</a>):</p>
   <blockquote>
     Method on string vs storage_buffer type: 
    <table>
     <tbody>
      <tr>
       <th>Strong Method
       <th>Method
       <th>Neutral
       <th>Type
       <th>Strong Type
      <tr>
       <td>9
       <td>2
       <td>3
       <td>2
       <td>2
    </table>
   </blockquote>
   <p>During the <a data-link-type="biblio" href="#biblio-koa">[KOA]</a> Meeting, LEWG expressed a preference for not weakening <code class="highlight"><c- n>basic_string</c-></code>'s invariants after <code class="highlight"><c- n>resize_default_init</c-></code> returns.  Under this
revision:</p>
   <ul>
    <li data-md>
     <p>A default-initialized buffer is <em>only</em> accessible to <code class="highlight"><c- n>op</c-></code>.</p>
    <li data-md>
     <p>Under penalty of undefined behavior, <code class="highlight"><c- n>op</c-></code> must assign (replace) the
   values in resulting buffer. The default initialized portion
   (<code class="highlight"><c- p>[</c-><c- n>data</c-><c- p>()</c-><c- o>+</c-><c- n>m</c-><c- p>,</c-> <c- n>data</c-><c- p>()</c-><c- o>+</c-><c- n>n</c-><c- p>)</c-></code>) above is erased and inaccessible to the
   program without further violation of class invariants.</p>
    <li data-md>
     <p>This proposal follows the "lambda" option discussed in <a data-link-type="biblio" href="#biblio-san">[SAN]</a>.</p>
   </ul>
   <p>Several other alternatives were discussed at <a data-link-type="biblio" href="#biblio-san">[SAN]</a>, <a data-link-type="biblio" href="#biblio-koa">[KOA]</a>, and on the
reflector.  Please see <a href="#alternatives">§ 6 Alternatives Considered</a> below for more details.</p>
   <h3 class="heading settled" data-level="5.2" id="allocator"><span class="secno">5.2. </span><span class="content">Allocator Interaction</span><a class="self-link" href="#allocator"></a></h3>
   <p>Unlocking the desired optimizations requires <em>some</em> change to <code class="highlight"><c- n>basic_string</c-></code>'s interaction with allocators. This proposal does what
we think is the simplest possible change: remove the requirement that <code class="highlight"><c- n>basic_string</c-></code> call <code class="highlight"><c- n>allocator_traits</c-><c- o>::</c-><c- n>construct</c-></code> or <code class="highlight"><c- n>allocator_traits</c-><c- o>::</c-><c- n>destroy</c-></code>.</p>
   <p>This restriction should be acceptable because <code class="highlight"><c- n>basic_string</c-></code> is
defined to only hold "non-array trivial standard-layout" types.
[<strong>strings.general</strong>] p1:</p>
   <blockquote>
    <p>This Clause describes components for manipulating sequences of any
non-array trivial standard-layout (6.7) type. Such types are called <em>char-like types</em>, and objects of <em>char-like types</em> are <em>called
char-like objects</em> or simply <em>characters</em>.</p>
   </blockquote>
   <p>Removing calls to <code class="highlight"><c- n>construct</c-></code> and <code class="highlight"><c- n>destroy</c-></code> is compatible with <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>basic_string</c-></code> as long as <code class="highlight"><c- n>uses_allocator_v</c-><c- o>&lt;</c-><c- n>charT</c-><c- o>></c-></code> is <code class="highlight">false</code>,
which should be the case in practice.</p>
   <p>Along the way, this proposal clarifies ambiguous language in
[<strong>string.require</strong>] and [<strong>container.requirements.general</strong>] by:</p>
   <ul>
    <li data-md>
     <p>Stating explicitly that <code class="highlight"><c- n>basic_string</c-></code> is allocator-aware.</p>
    <li data-md>
     <p>Introducing the term "allocator-aware" earlier in
  [<strong>container.requirements.general</strong>].</p>
    <li data-md>
     <p>Not attempting to mention other "components" in
  [<strong>container.requirements.general</strong>]. The other allocator-aware
  containers (just <code class="highlight"><c- n>basic_string</c-></code> and <code class="highlight"><c- n>regex</c-><c- o>::</c-><c- n>match_results</c-></code>?) can
  independently state that they are "allocator-aware" in their own
  clauses.</p>
   </ul>
   <p>libstdc++ and msvc allow strings of non-trivial type. That might force
those libraries to continue to support <code class="highlight"><c- n>construct</c-></code> and <code class="highlight"><c- n>destroy</c-></code> as
"extensions". On the other hand, libc++ disallows non-trivial <code class="highlight"><c- n>charT</c-></code>s, so any such extensions are non-portable. See <a href="https://godbolt.org/#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAKxAEZSAbAQwDtRkBSAJgCFufSAZ1QBXYskwgA5NwDMeFsgYisAag6yAwoILEFwDdg4AGAIInTO9CBAAjJoLzIA%2Bjr1sN2gtZBv9h1QAzVFQIAEp1AHY%2BM1U41Ssbe0cXPw8tRN9df1lsBI0Y03iEgDpiTEcAL0wILjCCi2LygjEWfNlCjkiAEQspMMZpAFYpUhZpY1HUaU1%2BfgTRcUx1LllaUYIJ/oGAaxBVksiATgAOABYzgDYuE64rs9pLy8GpM9HxqUnSaalRwRBjKRNp9%2BqQ4LAYIgUKgALYABzwDEwZAoEDQ8MRyJQzDYzl0IhYO1IgURBGR/wgti2pFsCiYxAAntJ1qR0TDMCwCAB5FgMJkg0hYGGsYBI6n4crIAh4ABuFWpmAAHphkCIyczRgoyQwNUC9DCtgMcew5rxGHhbP9IANUHDpagWP8pABaKwMC0abru2ycXj8P6LCR0I3Dd7Un6Kk6XZ2XM6qJQi1QQfGEiIQXCEEgrNakVSaWEIpHEbO0CKzP28DaG3YgIZHEpHSKRO60c6RIa0SLGWRDF5vUgGoaAj5fH5/AFAw1gyEQJCiAhwtXkSjowtY%2BiYfBEYh0UgAd2ITDhGpDUhGY3D0jktFUe8ICFUkejsfjxqTKZ2YSrILCAwQmCYLAd3CPtRkHYdL1%2BIQJ2BSZf1IPYDi4Otbi4LgjlkM4hlkI4zheWQwwFMdJx/ad4HBKFV0xFEVwLaiQGAQQWCPQQEFQAhiVJclKCpAVaWYxldTZDluV5fkviFEUxQFCUVWlOUnS%2BJUVTVSQpBZLVMB1dSNn1KdjRQU0BG9K0QNte1HWkAMxCDUsXnPEcpmkJ8YzjYBkGQd9iAJT8kwzbcS1zfMMSLbM6jzIzvzgv8AKAygazuEoTlodDaDS44TiOdCuFAgdawgoirOgwFYNBCjZxAedFw41EqKLfZSE3TMd3oA8jxPezCNHK9Vi4W970fKNXNUdzPOTbzUyi7ZSH/QCsRA7T%2B3Ai9Cqg/4SurBD9iGEorijG5uzOSIjtjfCuqcqDSoGcqZyQOrkWXNE6PqqQZWQOE4WcGVaCOZxaCGZwIBlQQ/oBk4wmcRVY1GEkGDJYgKV4r5%2BPpfkWWEzkeT5cVMGFNhpIkvBJXk%2BUBWU1V1R08hOS03VsgNUiDN9PgzRM%2BAbTtPAHSdaylmDTqVu6qQobjGFBDe1Rvvrf6kwANQAZVUf6krTfys2vILnuRbNZDLSKSOimbYvmmtaDOEocJOYxjCGS5ZG7S4TiGVZcuWxzviK9aDbK27KrVarHvundZEarcSF3Nrjx008HMguRZH6ggHxF1QxYlqWShliAFaVnbwam%2BDZrihbpCW/LBYu8cNp/BLIl2yI1m7WRMtkTDkOebSCIrj3Ls27SuHOnuC4GOUEa58YziAA%3D%3D%3D">godbolt.org</a>.</p>
   <h3 class="heading settled" data-level="5.3" id="bikeshed"><span class="secno">5.3. </span><span class="content">Bikeshedding</span><a class="self-link" href="#bikeshed"></a></h3>
   <p>What do we want to call this method?</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>resize_default_init</c-></code> (as proposed). This is consistent with <code class="highlight"><c- n>make_unique_default_init</c-></code> <a data-link-type="biblio" href="#biblio-p1020r1">[P1020R1]</a>, adopted in San Diego. Also,
  specifying default-initialization throws a bone to libraries that
  have historically allowed non-trivial <code class="highlight"><c- n>charT</c-></code> types in <code class="highlight"><c- n>basic_string</c-></code>.</p>
    <li data-md>
     <p><code class="highlight"><c- n>resize_uninitialized</c-></code> (as proposed in R0). "Uninitialized" is
  different from "default-initialized", which is what we want to
  specify. Also, <code class="highlight"><c- n>uninitialized</c-></code> is already used elsewhere in the
  Library to mean "not constructed at all", as in <code class="highlight"><c- n>uninitialized_copy</c-></code>; so this would be an overloading of the term.</p>
   </ul>
   <h2 class="heading settled" data-level="6" id="alternatives"><span class="secno">6. </span><span class="content">Alternatives Considered</span><a class="self-link" href="#alternatives"></a></h2>
   <h3 class="heading settled" data-level="6.1" id="tag"><span class="secno">6.1. </span><span class="content">Tag Type</span><a class="self-link" href="#tag"></a></h3>
   <p>At the <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting, LEWG showed support for a tag argument type:</p>
   <blockquote>
     Approval (vote for as many as you find acceptable) 
    <table>
     <tbody>
      <tr>
       <td>13 
       <td><strong>Go back to resize_uninitialized</strong>
      <tr>
       <td>15 
       <td><strong>Do tag type (default_initialize) for c’tor / resize()</strong>
      <tr>
       <td>12 
       <td><strong>Continue with storage_buffer (as per R2 of this paper)</strong>
      <tr>
       <td> 7 
       <td><strong>Crack open with a lambda</strong>
      <tr>
       <td> 7 
       <td><strong>RAII separate type</strong>
    </table>
   </blockquote>
   <p>For example:</p>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>GeneratePattern</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>pattern</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>count</c-><c- p>)</c-> <c- p>{</c->
   <c- k>const</c-> <c- k>auto</c-> <c- n>step</c-> <c- o>=</c-> <c- n>pattern</c-><c- p>.</c-><c- n>size</c-><c- p>();</c->

   <c- c1>// GOOD:  No initialization</c->
   <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>ret</c-><c- p>(</c-><c- n>step</c-> <c- o>*</c-> <c- n>count</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>::</c-><c- n>default_init</c-><c- p>);</c->
   <c- k>for</c-> <c- p>(</c-><c- b>size_t</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>;</c-> <c- n>i</c-><c- o>++</c-><c- p>)</c-> <c- p>{</c->
     <c- c1>// GOOD: No bookkeeping</c->
     <c- n>memcpy</c-><c- p>(</c-><c- n>ret</c-><c- p>.</c-><c- n>data</c-><c- p>()</c-> <c- o>+</c-> <c- n>i</c-> <c- o>*</c-> <c- n>step</c-><c- p>,</c-> <c- n>pattern</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>step</c-><c- p>);</c->
   <c- p>}</c->

   <c- k>return</c-> <c- n>ret</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>Benefits:</p>
   <ul>
    <li data-md>
     <p>A constructor that takes a tag type simplifies some use cases, like
  the example above.</p>
    <li data-md>
     <p>Matches existing practice in Boost. See <a href="#boost">§ 7.7 Boost</a>.</p>
   </ul>
   <p>Drawbacks:</p>
   <ul>
    <li data-md>
     <p>Feature creep / complexity — A tag type invites generalizing for all
  allocator-aware container types. We agree that this is desirable and
  even has implementation experience in Boost. However default
  initialization is not enough. There is also "implicit construction"
  (see <a data-link-type="biblio" href="#biblio-p1010r1">[P1010R1]</a>, <a data-link-type="biblio" href="#biblio-p0593r2">[P0593R2]</a>) and "relocation" (see <a data-link-type="biblio" href="#biblio-p1144r0">[P1144R0]</a>, <a data-link-type="biblio" href="#biblio-p1029r1">[P1029R1]</a>). Neither of these features are yet in the language. It
  is too early to generalize. Note that the second poll quoted in <a href="#mot">§ 1 Motivation</a> shows support for solving this problem for <code class="highlight"><c- p>[</c-><c- n>basic_</c-><c- p>]</c-><c- n>string</c-></code> but not <code class="highlight"><c- n>vector</c-></code>.</p>
    <li data-md>
     <p>In reflector discussion of <code class="highlight"><c- n>make_unique_default_init</c-></code> <a data-link-type="biblio" href="#biblio-zero">[Zero]</a>,
  there was a preference for avoiding tag types. The standard library
  has <code class="highlight"><c- n>copy_backward</c-></code>, not <code class="highlight"><c- n>copy</c-></code> with a tag, and <code class="highlight"><c- n>count_if</c-></code>, rather
  than <code class="highlight"><c- n>count</c-></code> with a predicate.</p>
   </ul>
   <p>Conclusion:</p>
   <p>LEWG should explore tags for allocator-aware containers, but that work
should not block near-term enablement of efficient [std::]string
builders.</p>
   <h3 class="heading settled" data-level="6.2" id="nonlambda"><span class="secno">6.2. </span><span class="content">Non-Lambda Approach</span><a class="self-link" href="#nonlambda"></a></h3>
   <p>In <a data-link-type="biblio" href="#biblio-p1072r0">[P1072R0]</a> and <a data-link-type="biblio" href="#biblio-p1072r3">[P1072R3]</a> of this proposal, the authors considered a
method <code class="highlight"><c- n>resize_default_init</c-></code> / <code class="highlight"><c- n>resize_uninitialized</c-></code> which left a
default-initialized buffer accessible to users of the <code class="highlight"><c- n>basic_string</c-></code> instance
after the method returned.  This method was rejected in <a data-link-type="biblio" href="#biblio-koa">[KOA]</a>, due to the
weakened class invariants.</p>
   <p>For illustration:</p>
<pre class="highlight"><c- k>extern</c-> <c- s>"C"</c-> <c- p>{</c->
  <c- b>int</c-> <c- n>compress</c-><c- p>(</c-><c- b>void</c-><c- o>*</c-> <c- n>out</c-><c- p>,</c-> <c- b>size_t</c-><c- o>*</c-> <c- n>out_size</c-><c- p>,</c-> <c- k>const</c-> <c- b>void</c-><c- o>*</c-> <c- n>in</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>in_size</c-><c- p>);</c->
  <c- b>size_t</c-> <c- nf>compressBound</c-><c- p>(</c-><c- b>size_t</c-> <c- n>bound</c-><c- p>);</c->
<c- p>}</c->

<c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>CompressWrapper</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>input</c-><c- p>)</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>compressed</c-><c- p>;</c->
    <c- c1>// Compute upper limit of compressed input.</c->
    <c- b>size_t</c-> <c- n>size</c-> <c- o>=</c-> <c- n>compressBound</c-><c- p>(</c-><c- n>input</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->

    <c- c1>// GOOD: No initialization</c->
    <c- n>compressed</c-><c- p>.</c-><c- n>resize_default_init</c-><c- p>(</c-><c- n>size</c-><c- p>);</c->
    <c- b>int</c-> <c- n>ret</c-> <c- o>=</c-> <c- n>compress</c-><c- p>(</c-><c- o>&amp;*</c-><c- n>compressed</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- o>&amp;</c-><c- n>size</c-><c- p>,</c-> <c- n>input</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>input</c-><c- p>.</c-><c- n>size</c-><c- p>());</c->
    <c- k>if</c-> <c- p>(</c-><c- n>ret</c-> <c- o>!=</c-> <c- n>OK</c-><c- p>)</c-> <c- p>{</c->
      <c- k>throw</c-> <c- p>...</c-><c- n>some</c-> <c- n>error</c-><c- p>...</c->
    <c- p>}</c->

    <c- c1>// Suppose size is the value of size before the call to compress and size'</c->
    <c- c1>// is the value of size after the call to compress.</c->
    <c- c1>//</c->
    <c- c1>// If size' &lt; size, then:</c->
    <c- c1>//   std::cout &lt;&lt; compressed[size' + 1]</c->
    <c- c1>// ...triggers a read of uninitialized data.</c->

    <c- c1>// Set actual size.</c->
    <c- n>compressed</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>size</c-><c- p>);</c->
    <c- k>return</c-> <c- n>compressed</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <h3 class="heading settled" data-level="6.3" id="buffer"><span class="secno">6.3. </span><span class="content">Standalone Type: <code class="highlight"><c- n>storage_buffer</c-></code></span><a class="self-link" href="#buffer"></a></h3>
   <p>In <a data-link-type="biblio" href="#biblio-p1072r1">[P1072R1]</a>, we considered <code class="highlight"><c- n>storage_buffer</c-></code>, a standalone type
providing a <code class="highlight"><c- n>prepare</c-></code> method (similar to the <code class="highlight"><c- n>resize_uninitialized</c-></code> method
proposed here) and <code class="highlight"><c- n>commit</c-></code> (to promise, under penalty of UB, that the
buffer had been initialized).</p>
   <p>At the <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting, this approach received support from LEWGI in light of
the <a data-link-type="biblio" href="#biblio-post-rapperswil">[post-Rapperswil]</a> email review indicating support for a distinct type.
This approach was rejected by the larger LEWG room in San Diego Meeting Diego.</p>
   <p>The proposed type would be move-only.</p>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>GeneratePattern</c-><c- p>(</c-><c- k>const</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>&amp;</c-> <c- n>pattern</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>count</c-><c- p>)</c-> <c- p>{</c->
   <c- n>std</c-><c- o>::</c-><c- n>storage_buffer</c-><c- o>&lt;</c-><c- b>char</c-><c- o>></c-> <c- n>tmp</c-><c- p>;</c->

   <c- k>const</c-> <c- k>auto</c-> <c- n>step</c-> <c- o>=</c-> <c- n>pattern</c-><c- p>.</c-><c- n>size</c-><c- p>();</c->
   <c- c1>// GOOD:  No initialization</c->
   <c- n>tmp</c-><c- p>.</c-><c- n>prepare</c-><c- p>(</c-><c- n>step</c-> <c- o>*</c-> <c- n>count</c-> <c- o>+</c-> <c- mi>1</c-><c- p>);</c->
   <c- k>for</c-> <c- p>(</c-><c- b>size_t</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>;</c-> <c- n>i</c-><c- o>++</c-><c- p>)</c-> <c- p>{</c->
     <c- c1>// GOOD: No bookkeeping</c->
     <c- n>memcpy</c-><c- p>(</c-><c- n>tmp</c-><c- p>.</c-><c- n>data</c-><c- p>()</c-> <c- o>+</c-> <c- n>i</c-> <c- o>*</c-> <c- n>step</c-><c- p>,</c-> <c- n>pattern</c-><c- p>.</c-><c- n>data</c-><c- p>(),</c-> <c- n>step</c-><c- p>);</c->
   <c- p>}</c->

   <c- n>tmp</c-><c- p>.</c-><c- n>commit</c-><c- p>(</c-><c- n>step</c-> <c- o>*</c-> <c- n>count</c-><c- p>);</c->
   <c- k>return</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>));</c->
<c- p>}</c->
</pre>
   <p>For purposes of the container API, <code class="highlight"><c- n>size</c-><c- p>()</c-></code> corresponds to the <em>committed</em> portion of the buffer.  This leads to more consistency when working with (and
explicitly copying to) other containers via iterators, for example:</p>
<pre class="highlight"><c- n>std</c-><c- o>::</c-><c- n>storage_buffer</c-><c- o>&lt;</c-><c- b>char</c-><c- o>></c-> <c- n>buf</c-><c- p>;</c->
<c- n>buf</c-><c- p>.</c-><c- n>prepare</c-><c- p>(</c-><c- mi>100</c-><c- p>);</c->
<c- o>*</c-><c- n>fill</c-> <c- n>in</c-> <c- n>data</c-><c- o>*</c->
<c- n>buf</c-><c- p>.</c-><c- n>commit</c-><c- p>(</c-><c- mi>50</c-><c- p>);</c->

<c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>a</c-><c- p>(</c-><c- n>buf</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>buf</c-><c- p>.</c-><c- n>end</c-><c- p>());</c->
<c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>b</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>buf</c-><c- p>));</c->

<c- n>assert</c-><c- p>(</c-><c- n>a</c-> <c- o>==</c-> <c- n>b</c-><c- p>);</c->
</pre>
   <p>Benefits:</p>
   <ul>
    <li data-md>
     <p>By being move-only, we would not have the risk of copying types with
trap representations (thereby triggering UB).</p>
    <li data-md>
     <p>Uninitialized data is only accessible from the <code class="highlight"><c- n>storage_buffer</c-></code> type.
For an API working with <code class="highlight"><c- n>basic_string</c-></code>, no invariants are weakened.
Crossing an API boundary with a <code class="highlight"><c- n>storage_buffer</c-></code> is much more obvious than
a "<code class="highlight"><c- n>basic_string</c-></code> with possibly uninitialized data."  Uninitialized bytes
(the promise made by <code class="highlight"><c- n>commit</c-></code>) never escape into the valid range of <code class="highlight"><c- n>basic_string</c-></code>.</p>
   </ul>
   <p>Drawbacks:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>storage_buffer</c-></code> requires introducing an extra type to the standard
library, even though its novel functionality (from <code class="highlight"><c- n>string</c-></code> and <code class="highlight"><c- n>vector</c-></code>) is limited to the initialization abilities.</p>
    <li data-md>
     <p><code class="highlight"><c- n>basic_string</c-></code> is often implemented with a short-string optimization (SSO) and an extra type would need to implement that (likely by additional checks when moving to/from the <code class="highlight"><c- n>storage_buffer</c-></code>) that are often unneeded.</p>
   </ul>
   <h3 class="heading settled" data-level="6.4" id="external"><span class="secno">6.4. </span><span class="content">Externally-Allocated Buffer Injection</span><a class="self-link" href="#external"></a></h3>
   <p>In <a data-link-type="biblio" href="#biblio-p1072r1">[P1072R1]</a>, we considered that <code class="highlight"><c- n>basic_string</c-></code> could "adopt" an
externally <code class="highlight"><c- n>allocator</c-><c- o>::</c-><c- n>allocate</c-></code>'d buffer. At the <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting, we
concluded that this was:</p>
   <ul>
    <li data-md>
     <p><strong>Not critical</strong></p>
    <li data-md>
     <p><strong>Not constrained in the future</strong></p>
    <li data-md>
     <p><strong>Overly constraining to implementers</strong>.  Allowing users to provide their own buffers runs into the "offset problem".  Consider an implementation that stores its <code class="highlight"><c- n>size</c-></code> and <code class="highlight"><c- n>capacity</c-></code> inline with its data, so <code class="highlight"><c- k>sizeof</c-><c- p>(</c-><c- n>container</c-><c- p>)</c-> <c- o>==</c-> <c- k>sizeof</c-><c- p>(</c-><c- b>void</c-><c- o>*</c-><c- p>)</c-></code>.</p>
<pre class="highlight"><c- k>class</c-> <c- nc>container</c-> <c- p>{</c->
  <c- k>struct</c-> <c- n>Rep</c-> <c- p>{</c->
    <c- b>size_t</c-> <c- n>size</c-><c- p>;</c->
    <c- b>size_t</c-> <c- n>capacity</c-><c- p>;</c->
  <c- p>};</c->

  <c- n>Rep</c-><c- o>*</c-> <c- n>rep_</c-><c- p>;</c->
<c- p>};</c->
</pre>
     <p>If using a <code class="highlight"><c- n>Rep</c-></code>-style implementation, the mismatch in offsets
requires an O(N) move to shift the contents into place and trigger a
possible reallocation.</p>
    <li data-md>
     <p><strong>Introducing new pitfalls</strong>.  It would be easy to mix <code class="highlight"><c- k>new</c-><c- p>[]</c-></code> and <code class="highlight"><c- n>allocator</c-><c- o>::</c-><c- n>allocate</c-></code> inadvertently.</p>
   </ul>
   <h2 class="heading settled" data-level="7" id="related"><span class="secno">7. </span><span class="content">Related Work</span><a class="self-link" href="#related"></a></h2>
   <h3 class="heading settled" data-level="7.1" id="google"><span class="secno">7.1. </span><span class="content">Google</span><a class="self-link" href="#google"></a></h3>
   <p>Google has a local extension to <code class="highlight"><c- n>basic_string</c-></code> called <code class="highlight"><c- n>resize_uninitialized</c-></code> which is wrapped as <code class="highlight"><c- n>STLStringResizeUninitialized</c-></code>.</p>
   <ul>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-abseil">[Abseil]</a> uses this to avoid bookkeeping overheads in <code class="highlight"><c- n>StrAppend</c-></code> and <code class="highlight"><c- n>StrCat</c-></code>.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-snappy">[Snappy]</a></p>
     <ul>
      <li data-md>
       <p>In <a href="https://github.com/google/snappy/blob/master/snappy.cc#L1318">decompression</a>, the final size of the output buffer is known before the contents are ready.</p>
      <li data-md>
       <p>During <a href="https://github.com/google/snappy/blob/master/snappy.cc#L1386">compression</a>, an upperbound on the final compressed size is known, allowing data to be efficiently added to the output buffer (eliding <code class="highlight"><c- n>append</c-></code>'s checks) and the string to be shrunk to its final, correct size.</p>
     </ul>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-protobuf">[Protobuf]</a> avoids extraneous copies or initialization when the
size is known before data is available (especially during parsing or
serialization).</p>
   </ul>
   <h3 class="heading settled" data-level="7.2" id="mongodb"><span class="secno">7.2. </span><span class="content">MongoDB</span><a class="self-link" href="#mongodb"></a></h3>
   <p>MongoDB has a string builder that could have been implemented in terms of <code class="highlight"><c- n>basic_string</c-></code> as a return value. However, as explained by Mathias Stearn, zero
initialization was measured and was too costly. Instead a custom string builder
type is used:</p>
   <p>E.g.: <a href="https://github.com/mongodb/mongo/blob/67da083face9dabdf95a5ffb72d3da675269b4c7/src/mongo/db/fts/unicode/string.h#L128-L143"> https://github.com/mongodb/mongo/blob/master/src/mongo/db/fts/unicode/string.h </a></p>
<pre class="highlight"><c- d>/**</c->
<c- d> * Strips diacritics and case-folds the utf8 input string, as needed to support</c->
<c- d> * options.</c->
<c- d> *</c->
<c- d> * The options field specifies what operations to *skip*, so kCaseSensitive</c->
<c- d> * means to skip case folding and kDiacriticSensitive means to skip diacritic</c->
<c- d> * striping. If both flags are specified, the input utf8 StringData is returned</c->
<c- d> * directly without any processing or copying.</c->
<c- d> *</c->
<c- d> * If processing is performed, the returned StringData will be placed in</c->
<c- d> * buffer.  buffer’s contents (if any) will be replaced. Since we may return</c->
<c- d> * the input unmodified the returned StringData’s lifetime is the shorter of</c->
<c- d> * the input utf8 and the next modification to buffer. The input utf8 must not</c->
<c- d> * point into buffer.</c->
<c- d> */</c->
<c- k>static</c-> <c- n>StringData</c-> <c- nf>caseFoldAndStripDiacritics</c-><c- p>(</c-><c- n>StackBufBuilder</c-><c- o>*</c-> <c- n>buffer</c-><c- p>,</c->
                                             <c- n>StringData</c-> <c- n>utf8</c-><c- p>,</c->
                                             <c- n>SubstrMatchOptions</c-> <c- n>options</c-><c- p>,</c->
                                             <c- n>CaseFoldMode</c-> <c- n>mode</c-><c- p>);</c->
</pre>
   <p>(Comments re-wrapped.)</p>
   <h3 class="heading settled" data-level="7.3" id="vmware"><span class="secno">7.3. </span><span class="content">VMware</span><a class="self-link" href="#vmware"></a></h3>
   <p>VMware has an internal string builder implementation that avoids <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> due, in part, to <code class="highlight"><c- n>reserve</c-></code>'s zero-writing behavior. This is similar in spirit to
the MongoDB example above.</p>
   <h3 class="heading settled" data-level="7.4" id="std-proposals"><span class="secno">7.4. </span><span class="content">Discussion on std-proposals</span><a class="self-link" href="#std-proposals"></a></h3>
   <p>This topic was discussed in 2013 on std-proposals in a thread titled "Add
basic_string::resize_uninitialized (or a similar mechanism)":<br> <a href="https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/XIO4KbBTxl0"> https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/XIO4KbBTxl0</a></p>
   <h3 class="heading settled" data-level="7.5" id="dynamicbuffer"><span class="secno">7.5. </span><span class="content">DynamicBuffer</span><a class="self-link" href="#dynamicbuffer"></a></h3>
   <p>The <a data-link-type="biblio" href="#biblio-n4734">[N4734]</a> (the Networking TS) has <em>dynamic buffer</em> types.</p>
   <h3 class="heading settled" data-level="7.6" id="p1021"><span class="secno">7.6. </span><span class="content">P1020R1</span><a class="self-link" href="#p1021"></a></h3>
   <p>See also <a data-link-type="biblio" href="#biblio-p1020r1">[P1020R1]</a> "Smart pointer creation functions for default
initialization". Adopted in San Diego.</p>
   <h3 class="heading settled" data-level="7.7" id="boost"><span class="secno">7.7. </span><span class="content">Boost</span><a class="self-link" href="#boost"></a></h3>
   <p>Boost provides a related optimization for vector-like containers,
introduced in <a href="https://github.com/boostorg/container/commit/14f092ab00def8e692b81d57d0466a617a6f6130"> [SVN r85964] </a> by Ion Gaztañaga.</p>
   <p>E.g.: <a href="https://github.com/boostorg/container/blob/develop/include/boost/container/vector.hpp"> boost/container/vector.hpp</a>:</p>
<pre class="highlight"><c- c1>//! &lt;b>Effects&lt;/b>: Constructs a vector that will use a copy of allocator a</c->
<c- c1>//!   and inserts n default initialized values.</c->
<c- c1>//!</c->
<c- c1>//! &lt;b>Throws&lt;/b>: If allocator_type’s allocation</c->
<c- c1>//!   throws or T’s default initialization throws.</c->
<c- c1>//!</c->
<c- c1>//! &lt;b>Complexity&lt;/b>: Linear to n.</c->
<c- c1>//!</c->
<c- c1>//! &lt;b>Note&lt;/b>: Non-standard extension</c->
<c- n>vector</c-><c- p>(</c-><c- n>size_type</c-> <c- n>n</c-><c- p>,</c-> <c- n>default_init_t</c-><c- p>);</c->
<c- n>vector</c-><c- p>(</c-><c- n>size_type</c-> <c- n>n</c-><c- p>,</c-> <c- n>default_init_t</c-><c- p>,</c-> <c- k>const</c-> <c- n>allocator_type</c-> <c- o>&amp;</c-><c- n>a</c-><c- p>)</c->
<c- p>...</c->
<c- b>void</c-> <c- n>resize</c-><c- p>(</c-><c- n>size_type</c-> <c- n>new_size</c-><c- p>,</c-> <c- n>default_init_t</c-><c- p>);</c->
<c- p>...</c->
</pre>
   <p>These optimizations are also supported in Boost Container’s <code class="highlight"><c- n>small_vector</c-></code>, <code class="highlight"><c- n>static_vector</c-></code>, <code class="highlight"><c- n>deque</c-></code>, <code class="highlight"><c- n>stable_vector</c-></code>, and <code class="highlight"><c- n>string</c-></code>.</p>
   <h3 class="heading settled" data-level="7.8" id="thrust"><span class="secno">7.8. </span><span class="content">Thrust</span><a class="self-link" href="#thrust"></a></h3>
   <p>The Thrust library has "a RAII-type <code class="highlight"><c- n>thrust</c-><c- o>::</c-><c- n>detail</c-><c- o>::</c-><c- n>temporary_array</c-></code> which has a vector-like interface and a constructor with a tag
parameter that indicates its elements should not be initialized." -
[Bryce Adelstein Lelbach].</p>
   <p>E.g. <a href="https://github.com/thrust/thrust/blob/417d78471dadefa3087ff274e64f43ce74acfd3d/thrust/detail/temporary_array.inl#L47">thrust/thrust/detail/temporary_array.inl</a>:</p>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>typename</c-> <c- n>T</c-><c- p>,</c-> <c- k>typename</c-> <c- n>TemporaryArray</c-><c- p>,</c-> <c- k>typename</c-> <c- n>Size</c-><c- o>></c->
<c- n>__host__</c-> <c- n>__device__</c->
<c- k>typename</c-> <c- n>thrust</c-><c- o>::</c-><c- n>detail</c-><c- o>::</c-><c- n>disable_if</c-><c- o>&lt;</c->
  <c- n>avoid_initialization</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>value</c->
<c- o>>::</c-><c- n>type</c->
  <c- n>construct_values</c-><c- p>(</c-><c- n>TemporaryArray</c-> <c- o>&amp;</c-><c- n>a</c-><c- p>,</c->
                   <c- n>Size</c-> <c- n>n</c-><c- p>)</c->
<c- p>{</c->
  <c- n>a</c-><c- p>.</c-><c- n>default_construct_n</c-><c- p>(</c-><c- n>a</c-><c- p>.</c-><c- n>begin</c-><c- p>(),</c-> <c- n>n</c-><c- p>);</c->
<c- p>}</c-> <c- c1>// end construct_values()</c->
</pre>
   <h2 class="heading settled" data-level="8" id="wording"><span class="secno">8. </span><span class="content">Wording</span><a class="self-link" href="#wording"></a></h2>
   <p>Wording is relative to <a data-link-type="biblio" href="#biblio-n4791">[N4791]</a>.</p>
   <p>Motivation for some of these edits can be found in <a href="#allocator">§ 5.2 Allocator Interaction</a>.</p>
   <h3 class="heading settled" data-level="8.1" id="basic.string"><span class="secno">8.1. </span><span class="content">[<strong>basic.string</strong>]</span><a class="self-link" href="#basic.string"></a></h3>
   <p>In [<strong>basic.string</strong>] [20.3.2], in the synopsis, add <code class="highlight"><c- n>resize_default_init</c-></code>:</p>
   <blockquote>
<pre>...
    // <em>20.3.2.4</em>, capacity
    size_type size() const noexcept;
    size_type length() const noexcept;
    size_type max_size() const noexcept;
    void resize(size_type n, charT c);
    void resize(size_type n);
    <ins>template<typename operation>
    void resize_default_init(size_type n, Operation op);</typename></ins>
    size_type capacity() const noexcept;
    void reserve(size_type res_arg);
    void shrink_to_fit();
    void clear() noexcept;
    [[nodiscard]] bool empty() const noexcept;
</pre>
   </blockquote>
   <p>In [<strong>string.require</strong>] [20.3.2.1] clarify that <code class="highlight"><c- n>basic_string</c-></code> is an
allocator-aware container, and then add an exception for <code class="highlight"><c- n>construct</c-></code> and <code class="highlight"><c- n>destroy</c-></code>.</p>
   <blockquote>
    <ol start="3">
     <li data-md>
      <p>
       In every specialization <code class="highlight"><c- n>basic_string</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- p>,</c-> <c- n>Allocator</c-><c- o>></c-></code>,
  the type <code class="highlight"><c- n>allocator_traits</c-><c- o>&lt;</c-><c- n>Allocator</c-><c- o>>::</c-><c- n>value_type</c-></code> shall name the
  same type as <code class="highlight"><c- n>charT</c-></code> 
       <del>. Every object of type <code class="highlight"><c- n>basic_string</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- p>,</c-> <c- n>Allocator</c-><c- o>></c-></code> uses an object of type <code class="highlight"><c- n>Allocator</c-></code> to allocate and free storage for the contained <code class="highlight"><c- n>charT</c-></code> objects as needed. The Allocator object used is obtained as
  described in [container.requirements.general]. In every
  specialization <code class="highlight"><c- n>basic_string</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- p>,</c-> <c- n>Allocator</c-><c- o>></c-></code></del>
       , 
       <ins> and</ins>
        the type <code class="highlight"><c- n>traits</c-></code> shall satisfy the character traits
  requirements ([char.traits]). [<em>Note:</em> The program is ill-formed if <code class="highlight"><c- n>traits</c-><c- o>::</c-><c- n>char_type</c-></code> is not the same type as <code class="highlight"><c- n>charT</c-></code>. — <em>end
  note</em>]
      </p>
    </ol>
    <ins>
     <ol start="4">
      <li data-md>
       <p><code class="highlight"><c- n>basic_string</c-></code> is an allocator-aware container as described in
  [container.requirements.general], except that it is
  implementation-defined whether <code class="highlight"><c- n>allocator_traits</c-><c- o>::</c-><c- n>construct</c-></code> and <code class="highlight"><c- n>allocator_traits</c-><c- o>::</c-><c- n>destroy</c-></code> are used to construct and destroy the
  contained <code class="highlight"><c- n>charT</c-></code> objects.</p>
     </ol>
    </ins>
    <ol start="5">
     <li data-md>
      <p>References, pointers, and iterators referring to the elements of a <code class="highlight"><c- n>basic_string</c-></code> sequence may be invalidated by the following uses of
  that <code class="highlight"><c- n>basic_string</c-></code> object:<br>...</p>
    </ol>
   </blockquote>
   <p>In [<strong>string.capacity</strong>] [20.3.2.4]:</p>
   <blockquote>
<pre>void resize(size_type n, charT c);
</pre>
    <ol start="6">
     <li>
      <em>Effects:</em> Alters the value of <code class="highlight"><c- o>*</c-><c- k>this</c-></code> as follows: 
      <ol>
       <li>— If <code class="highlight"><c- n>n</c-> <c- o>&lt;=</c-> <c- n>size</c-><c- p>()</c-></code>, erases the last <code class="highlight"><c- n>size</c-><c- p>()</c-> <c- o>-</c-> <c- n>n</c-></code> elements.
       <li>— If <code class="highlight"><c- n>n</c-> <c- o>></c-> <c- n>size</c-><c- p>()</c-></code>, appends <code class="highlight"><c- n>n</c-> <c- o>-</c-> <c- n>size</c-><c- p>()</c-></code> copies of <code class="highlight"><c- n>c</c-></code>.
      </ol>
    </ol>
<pre>void resize(size_type n);
</pre>
    <ol start="7">
     <li><em>Effects:</em> Equivalent to <code class="highlight"><c- n>resize</c-><c- p>(</c-><c- n>n</c-><c- p>,</c-> <c- n>charT</c-><c- p>())</c-></code>.
    </ol>
    <ins>
<pre>void resize_default_init(size_type n);
</pre>
     <ol start="8">
      <li>
       <em>Effects:</em> Alters the value of <code class="highlight"><c- o>*</c-><c- k>this</c-></code> as follows: 
       <ol>
        <li>— If <code class="highlight"><c- n>n</c-> <c- o>&lt;=</c-> <c- n>size</c-><c- p>()</c-></code>, erases the last <code class="highlight"><c- n>size</c-><c- p>()</c-> <c- o>-</c-> <c- n>n</c-></code> elements.
        <li>— If <code class="highlight"><c- n>n</c-> <c- o>></c-> <c- n>size</c-><c- p>()</c-></code>, appends <code class="highlight"><c- n>n</c-> <c- o>-</c-> <c- n>size</c-><c- p>()</c-></code> default-initialized
         elements.
       </ol>
      <li><em>Remarks:</em> Let <code class="highlight"><c- n>m</c-> <c- o>=</c-> <c- n>op</c-><c- p>(</c-><c- n>data</c-><c- p>(),</c-> <c- n>n</c-><c- p>)</c-></code>. <code class="highlight"><c- n>op</c-></code> shall replace
    ([<strong>expr.ass</strong>]) the values stored in the character array <code class="highlight"><c- p>[</c-><c- n>data</c-><c- p>(),</c-> <c- n>data</c-><c- p>()</c-><c- o>+</c-><c- n>m</c-><c- p>)</c-></code>. 
     </ol>
    </ins>
<pre>size_type capacity() const noexcept;
</pre>
    <p>...</p>
   </blockquote>
   <h3 class="heading settled" data-level="8.2" id="container"><span class="secno">8.2. </span><span class="content">[<strong>container.requirements.general</strong>]</span><a class="self-link" href="#container"></a></h3>
   <p>In [<strong>container.requirements.general</strong>] [21.2.1] clarify the ambiguous
"components affected by this subclause" terminology in p3. Just say
"allocator-aware containers".</p>
   <blockquote>
    <ol start="3">
     <li>
      <ins>All of the containers defined in this Clause except <code class="highlight"><c- n>array</c-></code> are allocator-aware containers.</ins>
      <del> For the components
    affected by this subclause that declare an allocator_type</del>
      <ins>Objects</ins>
      <del>objects</del>
       stored in 
      <del> these components </del>
      <ins> allocator-aware containers, unless otherwise specified, </ins>
       shall be constructed using the function <code class="highlight"><c- n>allocator_traits</c-><c- o>&lt;</c-><c- n>allocator_type</c-><c- o>>::</c-><c- n>rebind_traits</c-><c- o>&lt;</c-><c- n>U</c-><c- o>>::</c-><c- n>construct</c-></code> and
    destroyed using the function <code class="highlight"><c- n>allocator_traits</c-><c- o>&lt;</c-><c- n>allocator_type</c-><c- o>>::</c-><c- n>rebind_traits</c-><c- o>&lt;</c-><c- n>U</c-><c- o>>::</c-><c- n>destroy</c-></code> (19.10.9.2). 
    </ol>
   </blockquote>
   <p>We can then simplify p15:</p>
   <blockquote>
    <ol start="15">
     <li>
      <del>All of the containers defined in this Clause and in 20.3.2
    except <code class="highlight"><c- n>array</c-></code> meet the additional requirements of an
    allocator-aware container, as</del>
      <ins> Allocator-aware
    containers meet the additional requirements described in Table
    67.</ins>
    </ol>
   </blockquote>
   <h2 class="heading settled" data-level="9" id="questions"><span class="secno">9. </span><span class="content">Questions for LEWG</span><a class="self-link" href="#questions"></a></h2>
   <ol>
    <li data-md>
     <p>Is LEWG satisfied with this approach?</p>
   </ol>
   <h2 class="heading settled" data-level="10" id="history"><span class="secno">10. </span><span class="content">History</span><a class="self-link" href="#history"></a></h2>
   <h3 class="heading settled" data-level="10.1" id="R3"><span class="secno">10.1. </span><span class="content">R3 → R4</span><a class="self-link" href="#R3"></a></h3>
   <ul>
    <li data-md>
     <p>Applied feedback from the <a data-link-type="biblio" href="#biblio-koa">[KOA]</a> meeting.</p>
    <li data-md>
     <p>Moved to using a callback routine, rather than leaving invariants
weakened from the time <code class="highlight"><c- n>resize_default_init</c-></code> returned until values
in the buffer were assigned.</p>
   </ul>
   <h3 class="heading settled" data-level="10.2" id="R2"><span class="secno">10.2. </span><span class="content">R2 → R3</span><a class="self-link" href="#R2"></a></h3>
   <ul>
    <li data-md>
     <p>Applied Jonathan Wakely’s editorial comments on <a href="#wording">§ 8 Wording</a>.</p>
    <li data-md>
     <p>Rebased on <a data-link-type="biblio" href="#biblio-n4791">[N4791]</a>.</p>
    <li data-md>
     <p>Editorial changes to <a href="#mot">§ 1 Motivation</a> and <a href="#tag">§ 6.1 Tag Type</a> to support our design
choice.</p>
    <li data-md>
     <p>Added the reference to <a data-link-type="biblio" href="#biblio-libc">[LIBC++]</a> in <a href="#impl">§ 3 Implementation</a>.</p>
   </ul>
   <h3 class="heading settled" data-level="10.3" id="R2①"><span class="secno">10.3. </span><span class="content">R1 → R2</span><a class="self-link" href="#R2①"></a></h3>
   <p>Applied feedback from <a data-link-type="biblio" href="#biblio-san">[SAN]</a> Meeting reviews.</p>
   <ul>
    <li data-md>
     <p>Reverted design to "option A" proposed in <a data-link-type="biblio" href="#biblio-p1072r0">[P1072R0]</a>.</p>
    <li data-md>
     <p>Switched from <code class="highlight"><c- n>resize_uninitialized</c-></code> to <code class="highlight"><c- n>resize_default_init</c-></code>.</p>
    <li data-md>
     <p>Added discussion of alternatives considered.</p>
    <li data-md>
     <p>Specified allocator interaction.</p>
    <li data-md>
     <p>Added wording.</p>
   </ul>
   <h3 class="heading settled" data-level="10.4" id="R1"><span class="secno">10.4. </span><span class="content">R0 → R1</span><a class="self-link" href="#R1"></a></h3>
   <p>Applied feedback from LEWG <a data-link-type="biblio" href="#biblio-post-rapperswil">[post-Rapperswil]</a> Email Review:</p>
   <ul>
    <li data-md>
     <p>Shifted to a new vocabulary types: <code class="highlight"><c- n>storage_buffer</c-></code> / <code class="highlight"><c- n>storage_node</c-></code></p>
     <ul>
      <li data-md>
       <p>Added presentation of <code class="highlight"><c- n>storage_buffer</c-></code> as a new container type</p>
      <li data-md>
       <p>Added presentation of <code class="highlight"><c- n>storage_node</c-></code> as a node-like type</p>
     </ul>
    <li data-md>
     <p>Added discussion of design and implementation considerations.</p>
    <li data-md>
     <p>Most of <a data-link-type="biblio" href="#biblio-p1010r1">[P1010R1]</a> Was merged into this paper.</p>
   </ul>
   <h2 class="heading settled" data-level="11" id="acknowledgments"><span class="secno">11. </span><span class="content">Acknowledgments</span><a class="self-link" href="#acknowledgments"></a></h2>
   <p>Thanks go to <strong>Arthur O’Dwyer</strong> for help with wording and proof
reading, to <strong>Jonathan Wakely</strong> for hunting down the language that
makes <code class="highlight"><c- n>basic_string</c-></code> allocator-aware, and to <strong>Glen Fernandes</strong>, <strong>Corentin Jabot</strong>, <strong>Billy O’Neal</strong>, and <strong>Mathias Stearn</strong> for
design discussion. Special thanks to <strong>Eric Fiselier</strong> for providing
the implmentation.</p>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don’t scroll to compensate for the ToC if we’re above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don’t know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn’t exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn’t standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don’t have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we’re at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can’t find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-abseil">[Abseil]
   <dd><a href="https://github.com/abseil/abseil-cpp">Abseil</a>. 2018-09-22. URL: <a href="https://github.com/abseil/abseil-cpp">https://github.com/abseil/abseil-cpp</a>
   <dt id="biblio-koa">[KOA]
   <dd><a href="http://wiki.edg.com/bin/view/Wg21kona2019/P1072">Kona Meeting Minutes</a>. 2019-02-19. URL: <a href="http://wiki.edg.com/bin/view/Wg21kona2019/P1072">http://wiki.edg.com/bin/view/Wg21kona2019/P1072</a>
   <dt id="biblio-libc">[LIBC++]
   <dd><a href="http://llvm.org/viewvc/llvm-project?view=revision&amp;revision=347589">Add basic_string::__resize_default_init (from P1072)</a>. 2018-11-26. URL: <a href="http://llvm.org/viewvc/llvm-project?view=revision&amp;revision=347589">http://llvm.org/viewvc/llvm-project?view=revision&amp;revision=347589</a>
   <dt id="biblio-msan">[MSan]
   <dd><a href="https://clang.llvm.org/docs/MemorySanitizer.html">Memory Sanitizer</a>. URL: <a href="https://clang.llvm.org/docs/MemorySanitizer.html">https://clang.llvm.org/docs/MemorySanitizer.html</a>
   <dt id="biblio-n4734">[N4734]
   <dd>Jonathan Wakely. <a href="https://wg21.link/n4734">Working Draft, C ++ Extensions for Networking</a>. 4 April 2018. URL: <a href="https://wg21.link/n4734">https://wg21.link/n4734</a>
   <dt id="biblio-n4791">[N4791]
   <dd>Richard Smith. <a href="https://wg21.link/n4791">Working Draft, Standard for Programming Language C++</a>. 26 November 2018. URL: <a href="https://wg21.link/n4791">https://wg21.link/n4791</a>
   <dt id="biblio-p0593r2">[P0593R2]
   <dd>Richard Smith. <a href="https://wg21.link/p0593r2">Implicit creation of objects for low-level object manipulation</a>. 11 February 2018. URL: <a href="https://wg21.link/p0593r2">https://wg21.link/p0593r2</a>
   <dt id="biblio-p1010r1">[P1010R1]
   <dd>Mark Zeren, Chris Kennelly. <a href="https://wg21.link/p1010r1">Container support for implicit lifetime types</a>. 8 October 2018. URL: <a href="https://wg21.link/p1010r1">https://wg21.link/p1010r1</a>
   <dt id="biblio-p1020r1">[P1020R1]
   <dd>Glen Joseph Fernandes, Peter Dimov. <a href="https://wg21.link/p1020r1">Smart pointer creation with default initialization</a>. 6 November 2018. URL: <a href="https://wg21.link/p1020r1">https://wg21.link/p1020r1</a>
   <dt id="biblio-p1029r1">[P1029R1]
   <dd>Niall Douglas. <a href="https://wg21.link/p1029r1">[[move_relocates]]</a>. 7 August 2018. URL: <a href="https://wg21.link/p1029r1">https://wg21.link/p1029r1</a>
   <dt id="biblio-p1072r0">[P1072R0]
   <dd>Chris Kennelly, Mark Zeren. <a href="https://wg21.link/p1072r0">Default Initialization for basic_string</a>. 4 May 2018. URL: <a href="https://wg21.link/p1072r0">https://wg21.link/p1072r0</a>
   <dt id="biblio-p1072r1">[P1072R1]
   <dd>Chris Kennelly, Mark Zeren. <a href="https://wg21.link/p1072r1">Optimized Initialization for basic_string and vector</a>. 7 October 2018. URL: <a href="https://wg21.link/p1072r1">https://wg21.link/p1072r1</a>
   <dt id="biblio-p1072r3">[P1072R3]
   <dd>Chris Kennelly, Mark Zeren. <a href="https://wg21.link/p1072r3">basic_string::resize_default_init</a>. 21 January 2019. URL: <a href="https://wg21.link/p1072r3">https://wg21.link/p1072r3</a>
   <dt id="biblio-p1144r0">[P1144R0]
   <dd>Arthur O'Dwyer, Mingxin Wang. <a href="https://wg21.link/p1144r0">Object relocation in terms of move plus destroy</a>. 4 October 2018. URL: <a href="https://wg21.link/p1144r0">https://wg21.link/p1144r0</a>
   <dt id="biblio-post-rapperswil">[post-Rapperswil]
   <dd><a href="http://lists.isocpp.org/lib-ext/2018/08/8299.php">LEWG Weekly - P1072</a>. 2018-08-26. URL: <a href="http://lists.isocpp.org/lib-ext/2018/08/8299.php">http://lists.isocpp.org/lib-ext/2018/08/8299.php</a>
   <dt id="biblio-protobuf">[Protobuf]
   <dd><a href="https://github.com/protocolbuffers/protobuf">Protocol Buffers</a>. 2018-09-22. URL: <a href="https://github.com/protocolbuffers/protobuf">https://github.com/protocolbuffers/protobuf</a>
   <dt id="biblio-san">[SAN]
   <dd><a href="http://wiki.edg.com/bin/view/Wg21sandiego2018/P1072">San Diego Meeting Minutes</a>. 2018-11-07. URL: <a href="http://wiki.edg.com/bin/view/Wg21sandiego2018/P1072">http://wiki.edg.com/bin/view/Wg21sandiego2018/P1072</a>
   <dt id="biblio-snappy">[Snappy]
   <dd><a href="https://github.com/google/snappy">Snappy</a>. 2018-09-21. URL: <a href="https://github.com/google/snappy">https://github.com/google/snappy</a>
   <dt id="biblio-valgrind">[Valgrind]
   <dd><a href="http://www.valgrind.org">Valgrind</a>. URL: <a href="http://www.valgrind.org">http://www.valgrind.org</a>
   <dt id="biblio-zero">[Zero]
   <dd><a href="http://lists.isocpp.org/lib-ext/2018/04/6712.php">Listening to our customers: Zero-initialization issue</a>. 2018-04-13. URL: <a href="http://lists.isocpp.org/lib-ext/2018/04/6712.php">http://lists.isocpp.org/lib-ext/2018/04/6712.php</a>
  </dl>