<!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>P2013R4: Freestanding Language: Optional &lt;code&gt;::operator new&lt;/code&gt;</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
 *     -> ins/del.c### for candidate and proposed changes (amendments)
 *
 * 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)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *   - .correction for "candidate corrections"       (div, aside, details, section)
 *   - .addition   for "candidate additions"         (div, aside, details, section)
 *   - .correction.proposed for "proposed corrections" (div, aside, details, section)
 *   - .addition.proposed   for "proposed additions"   (div, aside, details, section)
 *
 * 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
 *
 * Outdated warning for old specs
 *
 * 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)
 *
 ******************************************************************************/

/* color variables included separately for reliability */

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

	html {
	}

	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;

		color: black;
		color: var(--text);
		background: white top left fixed no-repeat;
		background: var(--bg) 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: solid var(--logo-bg);
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		background: var(--logo-bg);
		color: white;
		color: var(--logo-text);
		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;
		background: var(--logo-active-bg);
		border-color: #c00;
		border-color: var(--logo-active-bg);
	}

	/* 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: 3;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

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

			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;

			color: #707070;
			color: var(--tocnav-normal-text);
			background: white;
			background: var(--tocnav-normal-bg);
		}
		#toc-nav > a:hover,
		#toc-nav > a:focus {
			color: black;
			color: var(--tocnav-hover-text);
			background: #f8f8f8;
			background: var(--tocnav-hover-bg);
		}
		#toc-nav > a:active {
			color: #c00;
			color: var(--tocnav-active-text);
			background: white;
			background: var(--tocnav-active-bg);
		}

		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		/* 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 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);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) 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);
			color: var(--tocsidebar-heading-text);
		}
		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);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) 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);
			color: var(--tocsidebar-heading-text);
		}

		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;
		color: var(--heading-text);
	}

	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,
	#profile-and-date {
		/* #profile-and-date 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) > :not(.head) + hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		color: black;
		color: var(--hr-text);
		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;
	border-left: 0.5em solid var(--algo-border);
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	 padding: .5em;
	 border: thin solid #ddd;
	 border: thin solid var(--algo-border);
	 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: inherit;
	}
	dfn var {
		font-style: normal;
	}

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

	del {
		color: #aa0000;
		color: var(--del-text);
		background: transparent;
		background: var(--del-bg);
		text-decoration: line-through;
	}
	ins {
		color: #006100;
		color: var(--ins-text);
		background: transparent;
		background: var(--ins-bg);
		text-decoration: underline;
	}

	/* for amendments (candidate/proposed changes) */

	.amendment ins, .correction ins, .addition ins,
	ins[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment del, .correction del, .addition del,
	del[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment.proposed ins, .correction.proposed ins, .addition.proposed ins,
	ins[class^=c].proposed {
		text-decoration-style: double;
	}
	.amendment.proposed del, .correction.proposed del, .addition.proposed del,
	del[class^=c].proposed {
		text-decoration-style: double;
	}

/** 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;
		hyphens: none;
		text-transform: none;
		text-align: left;
		text-align: start;
		font-variant: normal;
		orphans: 3;
		widows: 3;
		page-break-before: avoid;
	}
	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;
		color: var(--a-normal-text);
		text-decoration: underline #707070;
		text-decoration: underline var(--a-normal-underline);
		text-decoration-skip-ink: none;
	}
	a:visited {
		color: #034575;
		color: var(--a-visited-text);
		text-decoration-color: #bbb;
		text-decoration-color: var(--a-visited-underline);
	}

	/* Indicate interaction with the link */
	a[href]:focus,
	a[href]:hover {
		text-decoration-thickness: 2px;
		text-decoratin
	}
	a[href]:active {
		color: #c00;
		color: var(--a-active-text);
		text-decoration-color: #c00;
		text-decoration-color: var(--a-active-underline);
	}

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

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

	img {
		border-style: none;
	}

	img, svg {
		/* Intentionally not color-scheme aware. */
		background: white;
	}

	/* 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;
		height: 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,
	.amendment, .correction, .addition {
		margin: 1em auto;
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	blockquote > :first-child,
	.note  > p:first-child,
	.issue > p:first-child,
	.amendment > p:first-child,
	.correction > p:first-child,
	.addition > p:first-child {
		margin-top: 0;
	}
	blockquote > :last-child,
	.note  > p:last-child,
	.issue > p:last-child,
	.amendment > p:last-child,
	.correction > p:last-child,
	.addition > p:last-child {
		margin-bottom: 0;
	}


	.issue::before, .issue > .marker,
	.example::before, .example > .marker,
	.note::before, .note > .marker,
	details.note > summary > .marker,
	.amendment::before, .amendment > .marker,
	details.amendment > summary > .marker,
	.addition::before, .addition > .marker,
	addition.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	correction.amendment > summary > .marker
	{
		text-transform: uppercase;
		padding-right: 1em;
	}

	.example::before, .example > .marker {
		display: block;
		padding-right: 0em;
	}

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

	blockquote {
		border-color: silver;
		border-color: var(--blockquote-border);
		background: transparent;
		background: var(--blockquote-bg);
		color: currentcolor;
		color: var(--blockquote-text);
	}

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

	.issue {
		border-color: #e05252;
		border-color: var(--issue-border);
		background: #fbe9e9;
		background: var(--issue-bg);
		color: black;
		color: var(--issue-text);
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		color: #831616;
		color: var(--issueheading-text);
	}
	/* 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;
		border-color: var(--example-border);
		background: #fcfaee;
		background: var(--example-bg);
		color: black;
		color: var(--example-text);
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		color: #574b0f;
		color: var(--exampleheading-text);
	}
	/* 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;
		border-color: var(--note-border);
		background: #e9fbe9;
		background: var(--note-bg);
		color: black;
		color: var(--note-text);
		overflow: auto;
	}

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

	details.note[open] > summary {
		border-bottom: 1px silver solid;
		border-bottom: 1px var(--notesummary-underline) solid;
	}

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

	.assertion {
		border-color: #AAA;
		border-color: var(--assertion-border);
		background: #EEE;
		background: var(--assertion-bg);
		color: black;
		color: var(--assertion-text);
	}

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

	.advisement {
		border-color: orange;
		border-color: var(--advisement-border);
		border-style: none solid;
		background: #fec;
		background: var(--advisement-bg);
		color: black;
		color: var(--advisement-text);
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement::before, .advisement > .marker {
		color: #b35f00;
		color: var(--advisementheading-text);
	}

/** Amendment Box *************************************************************/

	.amendment, .correction, .addition {
		border-color: #330099;
		border-color: var(--amendment-border);
		background: #F5F0FF;
		background: var(--amendment-bg);
		color: black;
		color: var(--amendment-text);
	}
	.amendment.proposed, .correction.proposed, .addition.proposed {
		border-style: solid;
		border-block-width: 0.25em;
	}
	.amendment::before, .amendment > .marker,
	details.amendment > summary::before, details.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	details.correction > summary::before, details.correction > summary > .marker,
	.addition::before, .addition > .marker,
	details.addition > summary::before, details.addition > summary > .marker {
		color: #220066;
		color: var(--amendmentheading-text);
	}
	.amendment.proposed::before, .amendment.proposed > .marker,
	details.amendment.proposed > summary::before, details.amendment.proposed > summary > .marker,
	.correction.proposed::before, .correction.proposed > .marker,
	details.correction.proposed > summary::before, details.correction.proposed > summary > .marker,
	.addition.proposed::before, .addition.proposed > .marker,
	details.addition.proposed > summary::before, details.addition.proposed > summary > .marker {
		font-weight: bold;
	}

/** 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: hsla(40,100%,50%,0.95);
		background: var(--warning-bg);
		color: black;
		color: var(--warning-text);
		padding: .75em 1em;
		border: red;
		border: var(--warning-border);
		border-style: solid none;
		box-shadow: 0 2px 8px black;
		text-align: center;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

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

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

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

	.def {
		padding: .5em 1em;
		background: #def;
		background: var(--def-bg);
		margin: 1.2em 0;
		border-left: 0.5em solid #8ccbf2;
		border-left: 0.5em solid var(--def-border);
		color: black;
		color: var(--def-text);
	}

/******************************************************************************/
/*                                    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;
		border-bottom: 1px solid var(--defrow-border);
	}

	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-color: var(--datacell-border);
		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;
		border-top: 1px solid var(--datacell-border);
		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;
		border: 1px solid var(--datacell-border);
		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: 0.1rem 1px 0;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Switch to using border-bottom for underlines */
		text-decoration: none;
		border-bottom: 1px solid;
		/* Reverse color scheme */
		color: black;
		color: var(--toclink-text);
		border-color: #3980b5;
		border-color: var(--toclink-underline);
	}
	.toc a:visited {
		color: black;
		color: var(--toclink-visited-text);
		border-color: #054572;
		border-color: var(--toclink-visited-underline);
	}
	.toc a:focus,
	.toc a:hover {
		background: rgba(75%, 75%, 75%, .25);
		background: var(--a-hover-bg);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	.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;
	}
	.toc {
		line-height: 1.1em;
	}

	/* 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 li { font-size:   85%;	}

	/* @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 li li li .secno { font-size: 85%; }
		.toc > li li li li li .secno { font-size: 100%; }

		.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; }
		}
		/* Loosen it on wide screens */
		@media screen and (min-width: 78em) {
			body:not(.toc-inline) :not(li) > .toc			 { margin-left:  4rem; }
			body:not(.toc-inline) .toc .secno				 { margin-left: -4rem; }
			body:not(.toc-inline) .toc > li li li			 { margin-left:  1rem; }
			body:not(.toc-inline) .toc > li li li .secno	  { margin-left: -5rem; }
			body:not(.toc-inline) .toc > li li li li .secno	{ margin-left: -6rem; }
			body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
	}
	/* } */

	@supports (display:grid) and (display:contents) {
		/* 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,
		#toc .content:focus {
			background: rgba(75%, 75%, 75%, .25);
			background: var(--a-hover-bg);
			border-bottom: 3px solid #054572;
			border-bottom: 3px solid var(--toclink-underline);
			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:not(.dfn-paneled) {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
			color: var(--indexinfo-text);
		}
	}

/** 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]) {
		color: black;
		color: var(--indextable-hover-text);
		background: #f7f8f9;
		background: var(--indextable-hover-bg);
	}

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

/** Outdated warning **********************************************************/

.outdated-spec {
	color: black;
	color: var(--outdatedspec-text);
	background-color: rgba(0,0,0,0.5);
	background-color: var(--outdatedspec-bg);
}

.outdated-warning {
	position: fixed;
	bottom: 50%;
	left: 0;
	right: 0;
	margin: 0 auto;
	width: 50%;
	background: maroon;
	background: var(--outdated-bg);
	color: white;
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	position: absolute;
	top: 0;
	right:0;
	margin: 0;
	border: 0;
	padding: 0.25em 0.5em;
	background: transparent;
	color: white;
	color: var(--outdated-text);
	font:1em sans-serif;
	text-align:center;
}

.outdated-warning span {
	display: block;
}

.outdated-collapsed {
	bottom: 0;
	border-radius: 0;
	width: 100%;
	padding: 0;
}

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

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

		.outdated-warning {
			position: absolute;
			border-style: solid;
			border-color: red;
		}

		.outdated-warning input {
			display: none;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}



/******************************************************************************/
/*                             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 {
		/* Magic to create good item positioning:
		  "content column" is 50ems wide at max; less on smaller screens.
		  Extra space (after ToC + content) is empty on the right.

		  1. When item < content column, centers item in column.
		  2. When content < item < available, left-aligns.
		  3. When item > available, fills available + scroll bar.
		*/
		display: grid;
		grid-template-columns: minmax(0, 50em);
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			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-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-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;
    }

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version c6f50773a, updated Fri Apr 16 16:45:47 2021 -0700" name="generator">
  <link href="https://wg21.link/P2013R4" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: var(--a-normal-text);
    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>
<style>/* style-colors */

/* Any --*-text not paired with a --*-bg is assumed to have a transparent bg */
:root {
    color-scheme: light dark;

    --text: black;
    --bg: white;

    --unofficial-watermark: url(https://www.w3.org/StyleSheets/TR/2016/logos/UD-watermark);

    --logo-bg: #1a5e9a;
    --logo-active-bg: #c00;
    --logo-text: white;

    --tocnav-normal-text: #707070;
    --tocnav-normal-bg: var(--bg);
    --tocnav-hover-text: var(--tocnav-normal-text);
    --tocnav-hover-bg: #f8f8f8;
    --tocnav-active-text: #c00;
    --tocnav-active-bg: var(--tocnav-normal-bg);

    --tocsidebar-text: var(--text);
    --tocsidebar-bg: #f7f8f9;
    --tocsidebar-shadow: rgba(0,0,0,.1);
    --tocsidebar-heading-text: hsla(203,20%,40%,.7);

    --toclink-text: var(--text);
    --toclink-underline: #3980b5;
    --toclink-visited-text: var(--toclink-text);
    --toclink-visited-underline: #054572;

    --heading-text: #005a9c;

    --hr-text: var(--text);

    --algo-border: #def;

    --del-text: red;
    --del-bg: transparent;
    --ins-text: #080;
    --ins-bg: transparent;

    --a-normal-text: #034575;
    --a-normal-underline: #bbb;
    --a-visited-text: var(--a-normal-text);
    --a-visited-underline: #707070;
    --a-hover-bg: rgba(75%, 75%, 75%, .25);
    --a-active-text: #c00;
    --a-active-underline: #c00;

    --blockquote-border: silver;
    --blockquote-bg: transparent;
    --blockquote-text: currentcolor;

    --issue-border: #e05252;
    --issue-bg: #fbe9e9;
    --issue-text: var(--text);
    --issueheading-text: #831616;

    --example-border: #e0cb52;
    --example-bg: #fcfaee;
    --example-text: var(--text);
    --exampleheading-text: #574b0f;

    --note-border: #52e052;
    --note-bg: #e9fbe9;
    --note-text: var(--text);
    --noteheading-text: hsl(120, 70%, 30%);
    --notesummary-underline: silver;

    --assertion-border: #aaa;
    --assertion-bg: #eee;
    --assertion-text: black;

    --advisement-border: orange;
    --advisement-bg: #fec;
    --advisement-text: var(--text);
    --advisementheading-text: #b35f00;

    --warning-border: red;
    --warning-bg: hsla(40,100%,50%,0.95);
    --warning-text: var(--text);

    --amendment-border: #330099;
    --amendment-bg: #F5F0FF;
    --amendment-text: var(--text);
    --amendmentheading-text: #220066;

    --def-border: #8ccbf2;
    --def-bg: #def;
    --def-text: var(--text);
    --defrow-border: #bbd7e9;

    --datacell-border: silver;

    --indexinfo-text: #707070;

    --indextable-hover-text: black;
    --indextable-hover-bg: #f7f8f9;

    --outdatedspec-bg: rgba(0, 0, 0, .5);
    --outdatedspec-text: black;
    --outdated-bg: maroon;
    --outdated-text: white;
    --outdated-shadow: red;

    --editedrec-bg: darkorange;
}</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-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-selflinks */

:root {
    --selflink-text: white;
    --selflink-bg: gray;
    --selflink-hover-text: black;
}
.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: var(--selflink-bg);
    color: var(--selflink-text);
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: var(--selflink-hover-text);
}

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

code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }

.highlight:not(.idl) { background: rgba(0, 0, 0, .03); }
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-darkmode */

@media (prefers-color-scheme: dark) {
    :root {
        --text: #ddd;
        --bg: black;

        --unofficial-watermark: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cg fill='%23100808' transform='translate(200 200) rotate(-45) translate(-200 -200)' stroke='%23100808' stroke-width='3'%3E%3Ctext x='50%25' y='220' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EUNOFFICIAL%3C/text%3E%3Ctext x='50%25' y='305' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EDRAFT%3C/text%3E%3C/g%3E%3C/svg%3E");

        --logo-bg: #1a5e9a;
        --logo-active-bg: #c00;
        --logo-text: white;

        --tocnav-normal-text: #999;
        --tocnav-normal-bg: var(--bg);
        --tocnav-hover-text: var(--tocnav-normal-text);
        --tocnav-hover-bg: #080808;
        --tocnav-active-text: #f44;
        --tocnav-active-bg: var(--tocnav-normal-bg);

        --tocsidebar-text: var(--text);
        --tocsidebar-bg: #080808;
        --tocsidebar-shadow: rgba(255,255,255,.1);
        --tocsidebar-heading-text: hsla(203,20%,40%,.7);

        --toclink-text: var(--text);
        --toclink-underline: #6af;
        --toclink-visited-text: var(--toclink-text);
        --toclink-visited-underline: #054572;

        --heading-text: #8af;

        --hr-text: var(--text);

        --algo-border: #456;

        --del-text: #f44;
        --del-bg: transparent;
        --ins-text: #4a4;
        --ins-bg: transparent;

        --a-normal-text: #6af;
        --a-normal-underline: #555;
        --a-visited-text: var(--a-normal-text);
        --a-visited-underline: var(--a-normal-underline);
        --a-hover-bg: rgba(25%, 25%, 25%, .2);
        --a-active-text: #f44;
        --a-active-underline: var(--a-active-text);

        --borderedblock-bg: rgba(255, 255, 255, .05);

        --blockquote-border: silver;
        --blockquote-bg: var(--borderedblock-bg);
        --blockquote-text: currentcolor;

        --issue-border: #e05252;
        --issue-bg: var(--borderedblock-bg);
        --issue-text: var(--text);
        --issueheading-text: hsl(0deg, 70%, 70%);

        --example-border: hsl(50deg, 90%, 60%);
        --example-bg: var(--borderedblock-bg);
        --example-text: var(--text);
        --exampleheading-text: hsl(50deg, 70%, 70%);

        --note-border: hsl(120deg, 100%, 35%);
        --note-bg: var(--borderedblock-bg);
        --note-text: var(--text);
        --noteheading-text: hsl(120, 70%, 70%);
        --notesummary-underline: silver;

        --assertion-border: #444;
        --assertion-bg: var(--borderedblock-bg);
        --assertion-text: var(--text);

        --advisement-border: orange;
        --advisement-bg: #222218;
        --advisement-text: var(--text);
        --advisementheading-text: #f84;

        --warning-border: red;
        --warning-bg: hsla(40,100%,20%,0.95);
        --warning-text: var(--text);

        --amendment-border: #330099;
        --amendment-bg: #080010;
        --amendment-text: var(--text);
        --amendmentheading-text: #cc00ff;

        --def-border: #8ccbf2;
        --def-bg: #080818;
        --def-text: var(--text);
        --defrow-border: #136;

        --datacell-border: silver;

        --indexinfo-text: #aaa;

        --indextable-hover-text: var(--text);
        --indextable-hover-bg: #181818;

        --outdatedspec-bg: rgba(255, 255, 255, .5);
        --outdatedspec-text: black;
        --outdated-bg: maroon;
        --outdated-text: white;
        --outdated-shadow: red;

        --editedrec-bg: darkorange;
    }
    /* In case a transparent-bg image doesn't expect to be on a dark bg,
       which is quite common in practice... */
    img { background: white; }
}
@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}

@media (prefers-color-scheme: dark) {
    .highlight:not(.idl) { background: rgba(255, 255, 255, .05); }

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 </head><body class="h-entry toc-sidebar"><p id="toc-nav"><a id="toc-jump" href="#toc"><span aria-hidden="true">↑</span> <span>Jump to Table of Contents</span></a><a id="toc-toggle" href="#toc"><span aria-hidden="true">←</span> <span>Collapse Sidebar</span></a></p>
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P2013R4<br>Freestanding Language: Optional <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code></h1>
   <h2 class="no-num no-toc no-ref heading settled" id="profile-and-date"><span class="content">Published Proposal, <time class="dt-updated" datetime="2021-05-03">2021-05-03</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     </dt><dd><a class="u-url" href="https://wg21.link/P2013R4">https://wg21.link/P2013R4</a>
     </dd><dt class="editor">Author:
     </dt><dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:ben.craig@gmail.com">Ben Craig</a> (<span class="p-org org">NI</span>)
     </dd><dt>Audience:
     </dt><dd>EWG
     </dd><dt>Project:
     </dt><dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
     </dd><dt>Source:
     </dt><dd><a href="https://github.com/ben-craig/freestanding_proposal/blob/master/core/new_delete.bs">github.com/ben-craig/freestanding_proposal/blob/master/core/new_delete.bs</a>
    </dd></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>In freestanding implementations, standardize existing practices and make the default allocating <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>s optional.</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="#revision_history"><span class="secno">1</span> <span class="content">Revision History</span></a>
     <ol class="toc">
      <li><a href="#r4"><span class="secno">1.1</span> <span class="content">R4</span></a>
      </li><li><a href="#r3"><span class="secno">1.2</span> <span class="content">R3</span></a>
      </li><li><a href="#r2"><span class="secno">1.3</span> <span class="content">R2</span></a>
      </li><li><a href="#r1"><span class="secno">1.4</span> <span class="content">R1</span></a>
      </li><li><a href="#r0"><span class="secno">1.5</span> <span class="content">R0</span></a>
     </li></ol>
    </li><li><a href="#the_changes"><span class="secno">2</span> <span class="content">What is changing</span></a>
    </li><li><a href="#non_changes"><span class="secno">3</span> <span class="content">What is staying the same</span></a>
    </li><li>
     <a href="#why"><span class="secno">4</span> <span class="content">Why?</span></a>
     <ol class="toc">
      <li><a href="#ill_formed_as_a_service"><span class="secno">4.1</span> <span class="content">No allocations allowed</span></a>
      </li><li><a href="#no_right_way"><span class="secno">4.2</span> <span class="content">No right way to allocate memory</span></a>
      </li><li><a href="#allocators"><span class="secno">4.3</span> <span class="content">What about allocators?</span></a>
      </li><li><a href="#virtual_dtors"><span class="secno">4.4</span> <span class="content"><code class="highlight"><c- k="">virtual</c-></code> destructors</span></a>
      </li><li><a href="#why_not_fix"><span class="secno">4.5</span> <span class="content">Why not fix <code class="highlight"><c- k="">virtual</c-></code> destructors, instead of keeping a no-op <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code>?</span></a>
      </li><li><a href="#feature_test_macro"><span class="secno">4.6</span> <span class="content">Feature test macro</span></a>
      </li><li><a href="#abuses"><span class="secno">4.7</span> <span class="content">Likely misuses and abuses</span></a>
     </li></ol>
    </li><li><a href="#experience"><span class="secno">5</span> <span class="content">Experience</span></a>
    </li><li>
     <a href="#polling"><span class="secno">6</span> <span class="content">Polling history</span></a>
     <ol class="toc">
      <li><a href="#ewg_aug_telecon"><span class="secno">6.1</span> <span class="content">Aug 19, 2020, EWG, Telecon</span></a>
      </li><li><a href="#ewg_prague"><span class="secno">6.2</span> <span class="content">Feb 14, 2020, EWG, Prague</span></a>
      </li><li><a href="#ewgi_prague"><span class="secno">6.3</span> <span class="content">Feb 12, 2020, EWGI, Prague</span></a>
      </li><li><a href="#sg14_jan_2020"><span class="secno">6.4</span> <span class="content">Jan 8, 2020 SG14 Telecon</span></a>
     </li></ol>
    </li><li>
     <a href="#design_alternatives"><span class="secno">7</span> <span class="content">Design Alternatives</span></a>
     <ol class="toc">
      <li><a href="#alternative_impl_def_op_new"><span class="secno">7.1</span> <span class="content">Alternative 0: Implementation defined allocating <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> (Proposed above)</span></a>
      </li><li><a href="#alternative_throwing_new"><span class="secno">7.2</span> <span class="content">Alternative 1: Optional throwing <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>s, no-op default deallocation functions</span></a>
      </li><li>
       <a href="#alternative_no_dealloc"><span class="secno">7.3</span> <span class="content">Alternative 2: No deallocation functions</span></a>
       <ol class="toc">
        <li><a href="#alt1_experience"><span class="secno">7.3.1</span> <span class="content">Experience</span></a>
       </li></ol>
      </li><li>
       <a href="#alternative_new_odr"><span class="secno">7.4</span> <span class="content">Alternative 3: No deallocation functions and new ODR-used rules for virtual destructors</span></a>
       <ol class="toc">
        <li><a href="#alt2_how"><span class="secno">7.4.1</span> <span class="content">How could this virtual destructor ODR-use change be implemented?</span></a>
        </li><li><a href="#alt2_abi"><span class="secno">7.4.2</span> <span class="content">ABI impact</span></a>
        </li><li><a href="#alt2_experience"><span class="secno">7.4.3</span> <span class="content">Experience</span></a>
       </li></ol>
      </li><li><a href="#alternative_nop_dealloc"><span class="secno">7.5</span> <span class="content">Alternative 4: Missing <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>, no-op default deallocation functions (Proposed in R3)</span></a>
     </li></ol>
    </li><li>
     <a href="#wording"><span class="secno">8</span> <span class="content">Wording</span></a>
     <ol class="toc">
      <li><a href="#new_delete"><span class="secno">8.1</span> <span class="content">new.delete</span></a>
     </li></ol>
    </li><li><a href="#ack"><span class="secno">9</span> <span class="content">Acknowledgments</span></a>
    </li><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>
     </li></ol>
   </li></ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="revision_history"><span class="secno">1. </span><span class="content">Revision History</span><a class="self-link" href="#revision_history"></a></h2>
   <h3 class="heading settled" data-level="1.1" id="r4"><span class="secno">1.1. </span><span class="content">R4</span><a class="self-link" href="#r4"></a></h3>
    Definitions of the allocation functions must now exist, but they now
 have implementation defined behavior on freestanding implementations 
(which encompasses UB). 
   <p>Rebasing to N4878.  Accounting for shifted numbering in [new.delete].</p>
   <h3 class="heading settled" data-level="1.2" id="r3"><span class="secno">1.2. </span><span class="content">R3</span><a class="self-link" href="#r3"></a></h3>
    Added <a href="#ewg_aug_telecon">EWG Aug 2020 telecon</a> polling results. 
   <p>In the design, an ODR-use without a definition no longer requires 
ill-formedness.  The intent is still the same, in that it typically 
results in a linker error.</p>
   <p>Updated grammar and ill-formedness of wording.</p>
   <p>Found an additional note in <a href="https://wg21.link/expr.new#10">expr.new/10</a> that needed adjustment.</p>
   <p>Deferred <a href="#feature_test_macro">feature test macro</a> decision to a future revision of <a href="https://wg21.link/P2198">P2198</a>.</p>
   <h3 class="heading settled" data-level="1.3" id="r2"><span class="secno">1.3. </span><span class="content">R2</span><a class="self-link" href="#r2"></a></h3>
    Making the status of "placement" new more obvious ("placement" new is still required). 
   <p>Added words in the design to indicate that the declarations in <code class="highlight"><c- o="">&lt;</c-><c- k="">new</c-><c- o="">&gt;</c-></code> are not changing.</p>
   <p>Mentioning that pointer safety remains unchanged.</p>
   <h3 class="heading settled" data-level="1.4" id="r1"><span class="secno">1.4. </span><span class="content">R1</span><a class="self-link" href="#r1"></a></h3>
    Added polling results from Prague <a href="#ewgi_prague">EWGI</a> and <a href="#ewg_prague">EWG</a>. 
   <p>Added discussion on <a href="#feature_test_macro">feature test macro</a>.</p>
   <p>Added discussion on <a href="#why_not_fix">not fixing virtual destructors</a>.</p>
   <p>Declaring that <code class="highlight"><c- k="">constexpr</c-> <c- k="">new</c-></code> must continue to work.</p>
   <p>Added <a href="#wording">wording</a>.</p>
   <p>Wording includes <a href="#new_delete">changes to library clauses</a>, so added LEWG to the audience.</p>
   <h3 class="heading settled" data-level="1.5" id="r0"><span class="secno">1.5. </span><span class="content">R0</span><a class="self-link" href="#r0"></a></h3>
    R0 of this paper was extracted from <a data-link-type="biblio" href="#biblio-p1105r1">[P1105R1]</a>. 
   <p>The proposed solution is different than the one proposed for 
P1105R1, but the motivation is the same.  The solution from P1105R1 is 
still listed as a design alternative.</p>
   <h2 class="heading settled" data-level="2" id="the_changes"><span class="secno">2. </span><span class="content">What is changing</span><a class="self-link" href="#the_changes"></a></h2>
    On freestanding systems without default heap storage, the replaceable allocation functions (i.e. allocating <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>, including the <code class="highlight"><c- n="">nothrow_t</c-></code> and <code class="highlight"><c- n="">align_val_t</c-></code>
 overloads, single and array forms) will have implementation defined 
behavior that does not need to do any kind of allocation.  The 
implementation could return <code class="highlight"><c- k="">nullptr</c-></code>,
 invoke undefined behavior, or whatever the implementer likes.  If a 
freestanding implementation provides one replaceable allocation function
 that meets the hosted requirements, then all the replaceable allocation
 functions shall meet the requirements.  Hopefully, compiler vendors 
will warn on heap usage by default in freestanding implementations, and 
allow the warnings to be disabled for the situations where the user 
provides their own <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>. 
   <p>As a consequence of the above, runtime coroutines on freestanding 
implementations that are relying on the global allocation functions will
 also have implementation defined behavior, so long as the vendor 
supplied implementation is being used.</p>
   <p>No other core language features require <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>. <a href="http://eel.is/c++draft/basic.stc.dynamic.allocation#5">basic.stc.dynamic.allocation</a></p>
   <p><code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> will be implementable as a no-op function on implementations that have do-nothing or undefined-behavior <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> implementations.</p>
   <h2 class="heading settled" data-level="3" id="non_changes"><span class="secno">3. </span><span class="content">What is staying the same</span><a class="self-link" href="#non_changes"></a></h2>
    The replaceable deallocating <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> functions are still required to be present. <code class="highlight"><c- k="">virtual</c-></code> destructors ODR-use their associated <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code>(<a href="http://eel.is/c++draft/basic.def.odr#7">basic.def.odr</a>), so keeping the global <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> allows those <code class="highlight"><c- k="">virtual</c-></code> destructors to continue building.  Alternatives to this choice are discussed in <a href="#design_alternatives">§ 7 Design Alternatives</a>. 
   <p>Calling <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> on a non-null pointer that did not come from <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> is still undefined behavior <a href="http://eel.is/c++draft/new.delete.single#12">new.delete.single</a> <a href="http://eel.is/c++draft/new.delete.array#11">new.delete.array</a>.  Calling <code class="highlight"><c- k="">delete</c-></code> on an object or base that didn’t come from <code class="highlight"><c- k="">new</c-></code> is still undefined behavior <a href="http://eel.is/c++draft/expr.delete#2">expr.delete</a>.  This is what makes a no-op <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> a valid strategy for freestanding vendor supplied <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> implementations.</p>
   <p>The replaceable allocation functions will still be implicitly declared at global scope in each translation unit <a href="http://eel.is/c++draft/basic.stc.dynamic.general#2">basic.stc.dynamic.general</a>.
  A definition of the replaceable allocation functions must still exist.
  Non-ODR-uses of the replaceable allocation functions are still 
permitted (e.g. inside of uninstantiated templates).  The declarations 
of <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> in the <code class="highlight"><c- o="">&lt;</c-><c- k="">new</c-><c- o="">&gt;</c-></code>
 header are still required to be present.  Implementations of the 
replaceable allocation functions can be performed by linking in an extra
 translation-unit with the definitions of the functions.</p>
   <p>"<code class="highlight"><c- k="">constexpr</c-> <c- k="">new</c-></code>"
 is still required to work, even when the vendor supplied replaceable 
allocation functions have not been replaced.  The calls to <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> are required to be omitted, so any undefined behavior in the <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> implementation will also be skipped.</p>
   <p>Non-allocating placement <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> (colloquially "placement new") and <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> (colloquially "placement delete") are still required to be present in freestanding implementations.</p>
   <p>Core language concepts of pointer safety remain unchanged.  Note that the pointer safety library facilities <a href="https://eel.is/c++draft/util.dynamic.safety">util.dynamic.safety</a>
 are not required to be present in freestanding implementations, and the
 author is not aware of any papers to make the pointer safety library 
facilities required in freestanding implementations.</p>
   <p>Hosted implementations are unchanged.  Users of freestanding 
implementations can still provide implementations of the replaceable 
allocation and deallocation functions.  The behavior of <code class="highlight"><c- k="">virtual</c-></code> destructors is unchanged.  The behavior of class specific <code class="highlight"><c- k="">operator</c-> <c- k="">new</c-></code> and <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> overloads is unchanged.  The requirements on user-provided <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> and <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code>
 overloads remains the same, particularly those requirements involving 
error behaviors.  Coroutines will behave the same so long as 
promise-specific allocators are used.  The storage for exception objects
 will remain unspecified.</p>
   <h2 class="heading settled" data-level="4" id="why"><span class="secno">4. </span><span class="content">Why?</span><a class="self-link" href="#why"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="ill_formed_as_a_service"><span class="secno">4.1. </span><span class="content">No allocations allowed</span><a class="self-link" href="#ill_formed_as_a_service"></a></h3>
    In space constrained and/or real-time environments, there is often 
no free store.  These environments often cannot tolerate the space 
overhead for the free store, or the non-determinism from using the free 
store.  In these environments, it is a desirable property for accidental
 global <code class="highlight"><c- k="">new</c-></code> usage to generate a diagnostic.  Compilers are capable of generating a diagnostic when they ODR-use a function (e.g. <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>). 
   <p>FreeRTOS allows for both static and dynamic allocation of OS constructs <a data-link-type="biblio" href="#biblio-freertos_staticvdynamic">[FreeRTOS_StaticVDynamic]</a>.  Static allocation in conjunction with <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> diagnostics can help avoid overhead and eliminate accidental usage.</p>
   <p>THREADX <a data-link-type="biblio" href="#biblio-threadx">[THREADX]</a>
 does not consider dynamic allocation a core service, and can be built 
without support for dynamic allocation in order to reduce application 
size.  THREADX also distinguishes between byte allocation (general 
purpose) vs. block allocation (no-fragmentation elements of fixed size 
in a pool).</p>
   <p>Also, by allowing a no-op <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> implementation, these space constrained applications can save code-size.  No code needs to be present for <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> synchronization, free block coalescing, or free block searching.</p>
   <h3 class="heading settled" data-level="4.2" id="no_right_way"><span class="secno">4.2. </span><span class="content">No right way to allocate memory</span><a class="self-link" href="#no_right_way"></a></h3>
    In some target environments, there is no "right" way to allocate 
memory.  In kernel and embedded domains, the implementer of the C++ 
toolchain doesn’t always know the "right" way to allocate memory on the 
target environment.  This makes it difficult to provide an 
implementation for <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>.  The implementer cannot even rely on the presence of <code class="highlight"><c- n="">malloc</c-></code>, as it runs into the same fundamental problems. 
   <p>As an example, in the Microsoft Windows kernel environment, there are two leading choices about where to get dynamic memory <a data-link-type="biblio" href="#biblio-mspools">[MSPools]</a>.
  Users can get memory from the non-paged pool, which is a safe, but 
scarce resource; or users can get memory from the paged pool, which is 
plentiful, but not accessible in many common kernel operations.  
Non-paged pool must be used any time the allocated memory needs to be 
accessible from an interrupt or from a "high IRQL" context.  The author 
has had experience with both paged pool and non-paged pool as defaults, 
with the predictable outcome of crashes with paged pool defaults and OOM
 with non-paged pool defaults.  The implementer of the C++ toolchain is 
not in a good position to make this choice for the user.</p>
   <p>In the Linux kernel environment, <code class="highlight"><c- n="">kmalloc</c-></code> <a data-link-type="biblio" href="#biblio-kmalloc">[kmalloc]</a> with the <code class="highlight"><c- n="">GFP_KERNEL</c-></code> flag should be used when allocating memory within the context of a process and outside of a lock, but the <code class="highlight"><c- n="">GFP_ATOMIC</c-></code>
 flag should be used when allocating memory outside the context of a 
process, such as inside of an interrupt.  The implementers of the C++ 
runtime are in no position to know which is the correct flag to use by 
default.  Using <code class="highlight"><c- n="">GFP_KERNEL</c-></code> when <code class="highlight"><c- n="">GFP_ATOMIC</c-></code> is needed will result in crashes from interrupt code and deadlocks.  Using <code class="highlight"><c- n="">GFP_ATOMIC</c-></code> when <code class="highlight"><c- n="">GFP_KERNEL</c-></code>
 is appropriate will result in reduced system performance, spurious OOM 
errors, and premature exhaustion of emergency memory pools.</p>
   <p>Freestanding implementations are intended to run without the benefit of an operating system (<a href="http://eel.is/c++draft/intro.compliance#7">intro.compliance</a>).
  However, the name of the function that supplies dynamic memory is 
usually an OS-specific detail.  The C++ implementation should not (and 
may not) know the name of the function to request memory.  The Windows 
kernel uses <code class="highlight"><c- n="">ExAllocatePoolWithTag</c-></code>.  In the Linux kernel, <code class="highlight"><c- n="">kmalloc</c-></code> is the main function to use.  In FreeBSD, a function named <code class="highlight"><c- n="">malloc</c-></code> is present, but it takes different arguments than the C standard library function of the same name.  FreeRTOS uses <code class="highlight"><c- n="">pvPortMalloc</c-></code>, and THREADX uses <code class="highlight"><c- n="">tx_byte_allocate</c-></code>.  Home-grown OSes will likely have other spellings for memory allocation routines.</p>
   <p>Today’s C++ implementations don’t provide <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>
 implementations for all possible targets.  Doing so isn’t a plausible 
goal, especially when the home-grown OSes are taken into account.  This 
means that users are already forced into choosing between not having <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>
 support and providing their own implementation.  We should acknowledge 
and standardize this existing practice, especially since we already have
 the extension point mechanism in place.</p>
   <h3 class="heading settled" data-level="4.3" id="allocators"><span class="secno">4.3. </span><span class="content">What about allocators?</span><a class="self-link" href="#allocators"></a></h3>
    The C++20 freestanding library does not include allocators. <a data-link-type="biblio" href="#biblio-p1642r1">[P1642R1]</a> proposes adding allocator machinery to freestanding, but doesn’t add <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">allocator</c-></code>
 itself.  In addition, none of the allocating standard containers are in
 C++20’s freestanding library or any current freestanding library 
proposal that the author is aware of.  From a minimalist freestanding 
perspective, allocators aren’t a solution. 
   <p>Allocators are still useful in a less-than-minimal freestanding 
implementation.  In environments with dynamic memory, custom allocators 
can be written and used with standard containers, assuming that the 
containers are present in the implementation.  This could be done even 
if a global <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> is not present.  The author has used <code class="highlight"><c- n="">stlport</c-><c- o="">::</c-><c- n="">vector</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">PageLockedAllocator</c-><c- o="">&gt;</c-></code> successfully in these environments.</p>
   <p><code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">allocator</c-></code> is implemented in terms of global <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>.  In practice, it would be easy for an implementation to have an implementation of <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">allocator</c-></code> in a header / module, and have that header still compile just fine.  If the user has provided a global <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>, then <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">allocator</c-></code> would have the same semantics as mandated for hosted implementations.  If the global <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> is vendor supplied, then uses of <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">allocator</c-></code> would invoke implementation defined behavior, and hopefully cause a diagnostic.</p>
   <p>Some facilities in the standard library (e.g. <code class="highlight"><c- n="">make_unique</c-></code>) are implemented in terms of <code class="highlight"><c- k="">new</c-></code>,
 and not an allocator interface.  It is useful to make these facilities 
generate diagnostics when dynamic memory isn’t available, and it is also
 useful to be able to control which memory pool is used by default.</p>
   <h3 class="heading settled" data-level="4.4" id="virtual_dtors"><span class="secno">4.4. </span><span class="content"><code class="highlight"><c- k="">virtual</c-></code> destructors</span><a class="self-link" href="#virtual_dtors"></a></h3>
    A no-op <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> is still provided in order to satisfy <code class="highlight"><c- k="">virtual</c-></code> destructors. <code class="highlight"><c- k="">virtual</c-></code> destructors ODR-use their associated <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code>(<a href="http://eel.is/c++draft/basic.def.odr#7">basic.def.odr</a>).  This approach has the disadvantage that there is a small, one-time overhead for the first <code class="highlight"><c- k="">virtual</c-></code> destructor in a program, even if there are no usages of <code class="highlight"><c- k="">new</c-></code> or <code class="highlight"><c- k="">delete</c-></code>.  The overhead is small though, and you only pay for the overhead if you use <code class="highlight"><c- k="">virtual</c-></code> destructors. 
   <p>Ideally, if neither <code class="highlight"><c- k="">new</c-></code> nor <code class="highlight"><c- k="">delete</c-></code> is ever called, we wouldn’t need an <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code>.  This proposal still requires some <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> to exist, though that <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> can be a no-op.</p>
   <h3 class="heading settled" data-level="4.5" id="why_not_fix"><span class="secno">4.5. </span><span class="content">Why not fix <code class="highlight"><c- k="">virtual</c-></code> destructors, instead of keeping a no-op <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code>?</span><a class="self-link" href="#why_not_fix"></a></h3>
    This paper attempts to standardize existing practice.  There is not any existing practice for "fixed" <code class="highlight"><c- k="">virtual</c-> <c- n="">destructors</c-></code>.  Note that this paper isn’t changing any requirements on <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> or <code class="highlight"><c- k="">virtual</c-></code>
 destructors.  It will be no more difficult to fix it in the future than
 it would be today.  A motivated author could attempt to fix the problem
 in a future paper. 
   <h3 class="heading settled" data-level="4.6" id="feature_test_macro"><span class="secno">4.6. </span><span class="content">Feature test macro</span><a class="self-link" href="#feature_test_macro"></a></h3>
    <a href="https://wg21.link/P2198R1">P2198R1</a> discusses the feature test macro in more depth, and provides a recommendation. 
   <p>In order to provide this macro, library implementations are going 
to require knowledge of the target environment.  That knowledge may be 
via a list of known target platforms that are detected at build time, or
 by having the builder of the implementation supply that information in a
 configuration flag.</p>
   <p>The most likely usage of a feature test macro for this feature is to conditionally define a custom <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>
 iff the implementation did not provide one by default.  This is 
dangerous territory, as it encourages libraries to provide the 
one-and-only <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> definition.  If two such libraries do this, then there is an ODR issue.</p>
   <p>Another likely usage is to fall back to an implementation that does not use the heap at all.</p>
<pre class="highlight"><c- cp="">#if defined(__cpp_lib_no_default_operator_new) &amp;&amp; __cpp_lib_no_default_operator_new &gt;= 20200913</c->
  <c- k="">using</c-> <c- n="">my_container</c-> <c- o="">=</c-> <c- n="">fixed_capacity_vector</c-><c- p="">;</c->
<c- cp="">#else</c->
  <c- k="">using</c-> <c- n="">my_container</c-> <c- o="">=</c-> <c- n="">my_vector</c-><c- p="">;</c->
<c- cp="">#endif</c->
</pre>
   <p>This is an imprecise check.  Even though there is no default 
operator new, there may be a user provided operator new that works fine.</p>
   <p>If this feature test macro were provided in the positive (<code class="highlight"><c- n="">__cpp_lib_has_default_operator_new</c-></code>), it wouldn’t be useful for a very long time.</p>
<pre class="highlight"><c- cp="">#if defined(__cpp_lib_has_default_operator_new) &amp;&amp; __cpp_lib_has_default_operator_new &gt;= 20200913</c->
  <c- k="">using</c-> <c- n="">my_container</c-> <c- o="">=</c-> <c- n="">my_vector</c-><c- p="">;</c->
<c- cp="">#else</c->
  <c- c1="">// spuriously triggers for C++20 and earlier code</c->
  <c- k="">using</c-> <c- n="">my_container</c-> <c- o="">=</c-> <c- n="">fixed_capacity_vector</c-><c- p="">;</c->
<c- cp="">#endif</c->
</pre>
   <p>If this feature test macro were provided in the negative (<code class="highlight"><c- n="">__cpp_lib_no_default_operator_new</c-></code>), it would be the only feature test macro that wouldn’t be required to be defined in a conforming implementation.</p>
   <p>All these considerations are deserving of dedicated SG10 discussion with <a href="https://wg21.link/P2198">P2198</a>, and should not hold up the progress of this paper.</p>
   <h3 class="heading settled" data-level="4.7" id="abuses"><span class="secno">4.7. </span><span class="content">Likely misuses and abuses</span><a class="self-link" href="#abuses"></a></h3>
    Users are likely to provide overloads of <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> that do not follow the requirements set forth in <a href="http://eel.is/c++draft/new.delete">new.delete</a>, particularly the requirements around throwing <code class="highlight"><c- n="">bad_alloc</c-></code>.
  Ignoring this requirement will still result in undefined behavior, 
just as it does in C++20.  Some compilers optimize assuming that the 
throwing forms of <code class="highlight"><c- k="">new</c-></code> will never return a null pointer <a data-link-type="biblio" href="#biblio-throwing_new">[throwing_new]</a>.
  A likely outcome of the undefined behavior is unexpectedly eliding 
null checks in the program source.  This problem already exists today, 
and this proposal makes it no worse. 
   <h2 class="heading settled" data-level="5" id="experience"><span class="secno">5. </span><span class="content">Experience</span><a class="self-link" href="#experience"></a></h2>
    The proposed design has field experience in a micro-controller 
environment.  GCC was used, and the language support library was 
intentionally omitted.  A no-op <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> was provided by the users.  The no-op <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code>
 enabled a small amount of code sharing between a hosted environment and
 this micro-controller environment.  Some shared code involved classes 
with <code class="highlight"><c- k="">virtual</c-></code> destructors. 
   <h2 class="heading settled" data-level="6" id="polling"><span class="secno">6. </span><span class="content">Polling history</span><a class="self-link" href="#polling"></a></h2>
   <h3 class="heading settled" data-level="6.1" id="ewg_aug_telecon"><span class="secno">6.1. </span><span class="content">Aug 19, 2020, EWG, Telecon</span><a class="self-link" href="#ewg_aug_telecon"></a></h3>
    After updating wording for “either/of”, mandates, and talking to 
SG10 about the feature test macro, P2013 is tentatively ready to be 
forwarded to CWG. Walter volunteers to check that this is done. 
   <p>SF/F/N/A/SA</p>
   <p>2/16/1/0/0</p>
   <h3 class="heading settled" data-level="6.2" id="ewg_prague"><span class="secno">6.2. </span><span class="content">Feb 14, 2020, EWG, Prague</span><a class="self-link" href="#ewg_prague"></a></h3>
    We are interested in freestanding having an optional operator new, please come back with wording 
   <p>SF/F/N/A/SA</p>
   <p>8/10/7/0/0</p>
   <h3 class="heading settled" data-level="6.3" id="ewgi_prague"><span class="secno">6.3. </span><span class="content">Feb 12, 2020, EWGI, Prague</span><a class="self-link" href="#ewgi_prague"></a></h3>
    Given the time constraints of the committee, should we spend additional committee effort on P2013? 
   <p>SF/F/N/A/SA</p>
   <p>7/6/1/0/0</p>
   <p>Is a Feature test macro a valuable addition to this paper?</p>
   <p>SF/F/N/A/SA</p>
   <p>0/5/5/2/0</p>
   <p>Do we believe that P2013 is sufficiently developed to be seen by EWG?</p>
   <p>SF/F/N/A/SA</p>
   <p>5/8/0/0/0</p>
   <h3 class="heading settled" data-level="6.4" id="sg14_jan_2020"><span class="secno">6.4. </span><span class="content">Jan 8, 2020 SG14 Telecon</span><a class="self-link" href="#sg14_jan_2020"></a></h3>
    Forward P2013 as is with the minor editing quotes 
   <p>SF/F/N/A/SA</p>
   <p>9/10/0/0/0</p>
   <p>approves to go to EWG</p>
   <h2 class="heading settled" data-level="7" id="design_alternatives"><span class="secno">7. </span><span class="content">Design Alternatives</span><a class="self-link" href="#design_alternatives"></a></h2>
   <h3 class="heading settled" data-level="7.1" id="alternative_impl_def_op_new"><span class="secno">7.1. </span><span class="content">Alternative 0: Implementation defined allocating <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> (Proposed above)</span><a class="self-link" href="#alternative_impl_def_op_new"></a></h3>
    This option preserves much functionality, without using any novel 
techniques.  The main disadvantage of this approach compared to existing
 techniques is that diagnosing the problem requires more work.  See 
above for further explanation. 
   <h3 class="heading settled" data-level="7.2" id="alternative_throwing_new"><span class="secno">7.2. </span><span class="content">Alternative 1: Optional throwing <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>s, no-op default deallocation functions</span><a class="self-link" href="#alternative_throwing_new"></a></h3>
    Rather than making all the replaceable allocation functions have 
implementation defined behavior, we could make just the throwing <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>s implementation defined (array and single form, with and without <code class="highlight"><c- n="">align_val_t</c-></code> parameters).  The library would still be required to meet the hosted requirements for <code class="highlight"><c- n="">nothrow_t</c-></code> overloads. 
   <p>The <code class="highlight"><c- n="">nothrow_t</c-></code> 
overloads are specified to forward to an appropriate throwing overload. 
 That implementation would still be fine on a system without dynamic 
storage available.  This alternative was not selected as it is more 
difficult to teach, and because the target audience would likely be 
astonished that the <code class="highlight"><c- n="">nothrow_t</c-></code> overload has a <code class="highlight"><c- k="">try</c-></code>/<code class="highlight"><c- k="">catch</c-></code> in it.</p>
   <h3 class="heading settled" data-level="7.3" id="alternative_no_dealloc"><span class="secno">7.3. </span><span class="content">Alternative 2: No deallocation functions</span><a class="self-link" href="#alternative_no_dealloc"></a></h3>
    The presence of the replaceable deallocation functions is implementation defined. <code class="highlight"><c- k="">virtual</c-></code> destructors will be ill-formed unless the implementation provides the deallocation function, the user provides a global <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> function, or the user provides a class specific <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> overload. 
   <p>This alternative has the benefit of being zero overhead and very 
explicit, but it has troublesome consequences for implementations.  
There are several language support classes that have <code class="highlight"><c- k="">virtual</c-></code> destructors, and something would need to be decided for them.  Notably, <code class="highlight"><c- n="">type_info</c-></code> and the <code class="highlight"><c- n="">exception</c-></code> hierarchy all have <code class="highlight"><c- k="">virtual</c-></code> destructors.  The standard library implementers may be prohibited from providing <code class="highlight"><c- k="">operator</c-> <c- k="">new</c-></code> and <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> overloads (<a href="http://eel.is/c++draft/conforming#member.functions-2">conforming#member.functions</a>).  Alternatively, the facilities that require classes with <code class="highlight"><c- k="">virtual</c-></code> destructors could all be off-limits until <code class="highlight"><c- k="">operator</c-> <c- k="">delete</c-></code> was made available.  This would eliminate many cases with exceptions, <code class="highlight"><c- k="">dynamic_cast</c-></code> on references, and <code class="highlight"><c- k="">typeid</c-></code>.</p>
   <p>If we were to adopt this alternative, many users would provide a no-op <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> in their code, giving their code the same semantics and trade-offs as the proposed solution.</p>
   <h4 class="heading settled" data-level="7.3.1" id="alt1_experience"><span class="secno">7.3.1. </span><span class="content">Experience</span><a class="self-link" href="#alt1_experience"></a></h4>
    This alternative has field experience.  MSVC’s /kernel <a data-link-type="biblio" href="#biblio-kernel_switch">[kernel_switch]</a> flag omits definitions for <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> and <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code>.  Users of Clang and GCC can choose to not link against the language support library, and therefore not have <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> and <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> support, as well as many other language support features. 
   <h3 class="heading settled" data-level="7.4" id="alternative_new_odr"><span class="secno">7.4. </span><span class="content">Alternative 3: No deallocation functions and new ODR-used rules for virtual destructors</span><a class="self-link" href="#alternative_new_odr"></a></h3>
    The presence of the replaceable deallocation functions is implementation defined.  Change <code class="highlight"><c- k="">virtual</c-></code> destructors so that they generate a partial vtable and don’t ODR-use <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code>.  Make <code class="highlight"><c- k="">new</c-></code> expressions ODR-use <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> and complete the vtable. 
   <h4 class="heading settled" data-level="7.4.1" id="alt2_how"><span class="secno">7.4.1. </span><span class="content">How could this virtual destructor ODR-use change be implemented?</span><a class="self-link" href="#alt2_how"></a></h4>
    First, this is only a problem that needs to be solved on systems 
without a default heap.  This means that typical user-mode desktop and 
server implementations would be unaffected. 
   <p>Existing linkers already have the ability to take multiple 
identical virtual table implementations and pick one for use in the 
final binary.  A potential implementation strategy is for compilers and 
linkers to support a new "weaker" linkage.  When the default heap is 
disabled, the compiler would emit a vtable with a <code class="highlight"><c- k="">nullptr</c-></code> or pure virtual function in the virtual destructor slot.  When <code class="highlight"><c- k="">new</c-></code>
 is called, a "stronger" linkage vtable would be emitted that has the 
deleting destructor in the virtual destructor slot.  The linker would 
then select a vtable with the strongest linkage available.  Today’s 
linkage would be considered "stronger".  Only partially filled vtables 
would have "weaker" linkage.</p>
   <h4 class="heading settled" data-level="7.4.2" id="alt2_abi"><span class="secno">7.4.2. </span><span class="content">ABI impact</span><a class="self-link" href="#alt2_abi"></a></h4>
    Mixing multiple object files into the same program should be fine, 
even if some of them have a default heap and some don’t.  All the 
regular / "strong" linkage vtables should be identical, and all the 
"weaker" linkage vtables should be identical.  If anyone in the program 
calls any form of <code class="highlight"><c- k="">new</c-></code>, the deleting destructor will be present and in the right slot.  If no-one calls <code class="highlight"><c- k="">new</c-></code> in the program, then no-one should be calling <code class="highlight"><c- k="">delete</c-></code>, and the empty vtable slot won’t be a problem. 
   <p>Shared libraries are trickier.  Vtables aren’t always emitted into
 every translation unit.  Take shared library "leaf" that has a default 
heap.  It depends upon shared library "root" that does not have a 
default heap.  If a class with a virtual destructor is defined in 
"root", along with its "key function", then a call to <code class="highlight"><c- k="">new</c-></code> on the class in "leaf" will generate an object with a partial vtable.  Calling <code class="highlight"><c- k="">delete</c-></code> on that object will cause UB (usually crashes).</p>
   <p>Lack of a default heap should generally be considered a trait of 
the platform.  Mixing this configuration shouldn’t be a common 
occurrence.</p>
   <h4 class="heading settled" data-level="7.4.3" id="alt2_experience"><span class="secno">7.4.3. </span><span class="content">Experience</span><a class="self-link" href="#alt2_experience"></a></h4>
    This alternative is novel, and does not have implementation or usage experience. 
   <h3 class="heading settled" data-level="7.5" id="alternative_nop_dealloc"><span class="secno">7.5. </span><span class="content">Alternative 4: Missing <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>, no-op default deallocation functions (Proposed in R3)</span><a class="self-link" href="#alternative_nop_dealloc"></a></h3>
    Rather than have the behavior of the replaceable global allocation 
functions be implementation defined on freestanding implementations, we 
could instead have their presence be optional.  At runtime, this is easy
 enough, as we can lean on ODR to do the work (zero definitions is not 
one definition).  This results in an IF-NDR program, but in practice, 
you either get a linker error, or you get the "right" behavior, because 
the calls to <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> were heap-elided. 
   <p>This approach is substantially more difficult with <code class="highlight"><c- k="">constexpr</c-> <c- k="">new</c-></code> though.  Colloquially, users would expect that uses of <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> at compile time would not require a runtime definition of <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>.  However, <code class="highlight"><c- k="">constexpr</c-></code> doesn’t work like that.  Implementations are permitted to emit a runtime definition of <code class="highlight"><c- k="">constexpr</c-></code>
 functions, as well as keep an internal representation for compile time 
evaluation, even if the function only happens to be used for constant 
evaluation.  The runtime definition could still cause linker errors, 
even if nothing is calling the function.</p>
   <p>It is possible to rework the ODR rules such that a runtime 
definition is only emitted if needed.  That is a substantially larger 
change though, and there was resistance from CWG to make this large of a
 change to ODR at this time.  This approach should be reconsidered for 
adoption if more OS-dependent facilities become available at compile in 
the future (e.g. <code class="highlight"><c- k="">constexpr</c-></code> iostreams).  A lower effort approach is acceptable for now though, since <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> and <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">delete</c-></code> are the only such facilities at present.</p>
   <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>
    This is based on the <a href="https://wg21.link/N4878">December working draft, N4878</a>. 
   <h3 class="heading settled" data-level="8.1" id="new_delete"><span class="secno">8.1. </span><span class="content">new.delete</span><a class="self-link" href="#new_delete"></a></h3>
    Modify <a href="https://wg21.link/new.delete">new.delete</a> 
   <blockquote>
    <p>17.6.3  Storage allocation and deallocation [new.delete]</p>
    <p>17.6.3.1  General [new.delete.general]</p>
    <p>1 Except where otherwise specified, the provisions of 6.7.5.5 
apply to the library versions of operator new and operator delete. If 
the value of an alignment argument passed to any of these functions is 
not a valid alignment value, the behavior is undefined.</p>
    <p>
     <ins>2
On freestanding implementations, it is implementation defined whether 
the behavior of the implementation-provided replaceable global 
allocation functions satisfy the required behaviors described in 
[new.delete.single] and [new.delete.array].</ins>
    </p>
    <p>
     <ins>[<i>Note</i>: A freestanding implementation can provide 
replaceable global allocation functions that cause undefined behavior.
During constant evaluation, the behavior of the implementation-provided 
replaceable global allocation functions is irrelevant, as those calls 
are omitted ([expr.new]).- <i>end note</i>]</ins>
    </p>
    <p>
     <ins><i>Recommended practice:</i> If any of the 
implementation-provided replaceable global allocation functions meet the
 requirements of a hosted implementation, they all should. </ins>
    </p>
   </blockquote>
   <h2 class="heading settled" data-level="9" id="ack"><span class="secno">9. </span><span class="content">Acknowledgments</span><a class="self-link" href="#ack"></a></h2>
    Thank you to the many reviewers of this paper:
Brandon Streiff, Irwan Djajadi, Joshua Cannon, Brad Keryan, Alfred 
Bratterud, Phil Hindman, Arthur O’Dwyer, Laurin-Luis Lehning, JF 
Bastien, Matthew Bentley, and Alisdair Meredith. 
   <p>Thank you to Daveed Vandevoorde and Walter Brown for providing feedback on the wording.</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-freertos_staticvdynamic">[FreeRTOS_StaticVDynamic]
   </dt><dd>FreeRTOS Documentation. <a href="https://www.freertos.org/Static_Vs_Dynamic_Memory_Allocation.html">Static Vs Dynamic Memory Allocation</a>. URL: <a href="https://www.freertos.org/Static_Vs_Dynamic_Memory_Allocation.html">https://www.freertos.org/Static_Vs_Dynamic_Memory_Allocation.html</a>
   </dd><dt id="biblio-kernel_switch">[KERNEL_SWITCH]
   </dt><dd>Microsoft Documentation. <a href="https://docs.microsoft.com/en-us/cpp/build/reference/kernel-create-kernel-mode-binary">/kernel (Create Kernel Mode Binary)</a>. URL: <a href="https://docs.microsoft.com/en-us/cpp/build/reference/kernel-create-kernel-mode-binary">https://docs.microsoft.com/en-us/cpp/build/reference/kernel-create-kernel-mode-binary</a>
   </dd><dt id="biblio-kmalloc">[KMALLOC]
   </dt><dd>kernel.org. <a href="https://www.kernel.org/doc/htmldocs/kernel-api/API-kmalloc.html">kmalloc</a>. URL: <a href="https://www.kernel.org/doc/htmldocs/kernel-api/API-kmalloc.html">https://www.kernel.org/doc/htmldocs/kernel-api/API-kmalloc.html</a>
   </dd><dt id="biblio-mspools">[MSPools]
   </dt><dd>Microsoft Documentation. <a href="https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_pool_type">POOL_TYPE enumeration</a>. URL: <a href="https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_pool_type">https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_pool_type</a>
   </dd><dt id="biblio-p1105r1">[P1105R1]
   </dt><dd>Ben Craig; Ben Saks. <a href="https://wg21.link/P1105R1">Leaving no room for a lower-level language: A C++ Subset</a>. URL: <a href="https://wg21.link/P1105R1">https://wg21.link/P1105R1</a>
   </dd><dt id="biblio-p1642r1">[P1642R1]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P1642R1">Freestanding Library: Easy [utilities], [ranges], and [iterators]</a>. URL: <a href="https://wg21.link/P1642R1">https://wg21.link/P1642R1</a>
   </dd><dt id="biblio-threadx">[THREADX]
   </dt><dd><a href="https://rtos.com/solutions/threadx/real-time-operating-system/">THREADX(R) RTOS - Royalty Free Real-Time Operating System</a>. URL: <a href="https://rtos.com/solutions/threadx/real-time-operating-system/">https://rtos.com/solutions/threadx/real-time-operating-system/</a>
   </dd><dt id="biblio-throwing_new">[THROWING_NEW]
   </dt><dd>Microsoft Documentation. <a href="https://docs.microsoft.com/en-us/cpp/build/reference/zc-throwingnew-assume-operator-new-throws?view=vs-2019">/Zc:throwingNew (Assume operator new throws)</a>. URL: <a href="https://docs.microsoft.com/en-us/cpp/build/reference/zc-throwingnew-assume-operator-new-throws?view=vs-2019">https://docs.microsoft.com/en-us/cpp/build/reference/zc-throwingnew-assume-operator-new-throws?view=vs-2019</a>
  </dd></dl></body></html>