<!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>P1144R7: std::is_trivially_relocatable</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;
	}
	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 a + span {
			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>
    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 71458e5bb, updated Thu Mar 9 17:18:51 2023 -0800" name="generator">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>
ins  {background-color: #CCFFCC; text-decoration: underline;}
del  {background-color: #FFCACA; text-decoration: line-through;}
</style>
<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-dfn-panel */
:root {
    --dfnpanel-bg: #ddd;
    --dfnpanel-text: var(--text);
}
.dfn-panel {
    position: absolute;
    z-index: 35;
    width: 20em;
    min-width: min-content;
    max-width: 300px;
    height: auto;
    max-height: 500px;
    overflow: auto;
    padding: 0.5em 0.75em;
    font: small Helvetica Neue, sans-serif, Droid Sans Fallback;
    background: var(--dfnpanel-bg);
    color: var(--dfnpanel-text);
    border: outset 0.2em;
    white-space: normal; /* in case it's moved into a pre */
}
.dfn-panel:not(.on) { display: none; }
.dfn-panel * { margin: 0; padding: 0; text-indent: 0; }
.dfn-panel > b { display: block; }
.dfn-panel a { color: var(--dfnpanel-text); }
.dfn-panel a:not(:hover) { text-decoration: none !important; border-bottom: none !important; }
.dfn-panel > b + b { margin-top: 0.25em; }
.dfn-panel ul { padding: 0; }
.dfn-panel li { list-style: inside; }
.dfn-panel.activated {
    display: inline-block;
    position: fixed;
    left: .5em;
    bottom: 2em;
    margin: 0 auto;
    max-width: calc(100vw - 1.5em - .4em - .5em);
    max-height: 30vh;
}

.dfn-paneled { cursor: pointer; }
</style>
<style>/* style-issues */
a[href].issue-return {
    float: right;
    float: inline-end;
    color: var(--issueheading-text);
    font-weight: bold;
    text-decoration: none;
}
</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%;
}
.example > a.self-link,
.note > a.self-link,
.issue > a.self-link {
    /* These blocks are overflow:auto, so positioning outside
       doesn't work. */
    left: auto;
    right: 0;
}
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>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1144R7<br>std::is_trivially_relocatable</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="2023-03-10">2023-03-10</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>Issue Tracking:
     <dd><a href="#issues-index">Inline In Spec</a>
     <dt class="editor">Author:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:arthur.j.odwyer@gmail.com">Arthur O'Dwyer</a>
     <dt>Audience:
     <dd>LEWG, EWG
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
     <dt>Draft Revision:
     <dd>42
     <dt>Current Source:
     <dd><a href="https://github.com/Quuxplusone/draft/blob/gh-pages/d1144-object-relocation.bs">github.com/Quuxplusone/draft/blob/gh-pages/d1144-object-relocation.bs</a>
     <dt>Current:
     <dd><a href="https://rawgit.com/Quuxplusone/draft/gh-pages/d1144-object-relocation.html">rawgit.com/Quuxplusone/draft/gh-pages/d1144-object-relocation.html</a>
    </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>We define a new verb, "relocate," equivalent to a move and a destroy.

  For many C++ types, the "relocate" operation is implementable as a single <code class="highlight"><c- n>memcpy</c-></code>.
  We provide a standard trait to detect types which are trivially relocatable, for the benefit of library writers.
  We provide a rule that correctly propagates trivial relocatability among Rule-of-Zero types.
  Finally, we provide a portable way for a user-defined type (e.g. <code class="highlight"><c- n>boost</c-><c- o>::</c-><c- n>shared_ptr</c-></code>) to warrant
  that it is trivially relocatable.
  P1144R3 was presented at C++Now 2019 as a 90-minute talk titled <a href="https://www.youtube.com/watch?v=SGdfPextuAU">"Trivially Relocatable."</a></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="#changelog"><span class="secno">1</span> <span class="content">Changelog</span></a>
    <li>
     <a href="#intro"><span class="secno">2</span> <span class="content">Introduction and motivation</span></a>
     <ol class="toc">
      <li>
       <a href="#applications"><span class="secno">2.1</span> <span class="content">Optimizations enabled by trivial relocatability</span></a>
       <ol class="toc">
        <li><a href="#benefit-resize"><span class="secno">2.1.1</span> <span class="content">Contiguous reallocation</span></a>
        <li><a href="#benefit-type-erasure"><span class="secno">2.1.2</span> <span class="content">Moving in-place/SBO type-erased types like <code class="highlight"><c- n>any</c-></code> and <code class="highlight"><c- n>function</c-></code></span></a>
        <li><a href="#benefit-fixed-capacity"><span class="secno">2.1.3</span> <span class="content">Moving fixed-capacity containers like <code class="highlight"><c- n>static_vector</c-></code> and <code class="highlight"><c- n>small_vector</c-></code></span></a>
        <li><a href="#benefit-insert-erase"><span class="secno">2.1.4</span> <span class="content">Contiguous insert and erase</span></a>
        <li><a href="#benefit-swap"><span class="secno">2.1.5</span> <span class="content">Swap</span></a>
       </ol>
      <li><a href="#benefit-assertions"><span class="secno">2.2</span> <span class="content">Assertions, not assumptions</span></a>
      <li><a href="#doing-it-wrong"><span class="secno">2.3</span> <span class="content">Eliminate manual warrants, improve safety</span></a>
     </ol>
    <li>
     <a href="#design-goals"><span class="secno">3</span> <span class="content">Design goals</span></a>
     <ol class="toc">
      <li><a href="#use1"><span class="secno">3.1</span> <span class="content">Standard library types such as <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code></span></a>
      <li><a href="#use2"><span class="secno">3.2</span> <span class="content">Program-defined types that follow the Rule of Zero</span></a>
      <li><a href="#use3"><span class="secno">3.3</span> <span class="content">Program-defined types with non-defaulted special members</span></a>
     </ol>
    <li>
     <a href="#wording"><span class="secno">4</span> <span class="content">Proposed wording for C++2b</span></a>
     <ol class="toc">
      <li><a href="#wording-algorithms.requirements"><span class="secno">4.1</span> <span class="content">Nothrow bidirectional iterator [algorithms.requirements]</span></a>
      <li><a href="#wording-defns.relocation"><span class="secno">4.2</span> <span class="content">Relocation operation [defns.relocation]</span></a>
      <li><a href="#wording-relocate"><span class="secno">4.3</span> <span class="content"><code class="highlight"><c- n>relocate_at</c-></code> and <code class="highlight"><c- n>relocate</c-></code> [specialized.relocate]</span></a>
      <li><a href="#wording-uninitialized.relocate"><span class="secno">4.4</span> <span class="content"><code class="highlight"><c- n>uninitialized_relocate</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_n</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_backward</c-></code> [uninitialized.relocate]</span></a>
      <li><a href="#wording-basic.types.general"><span class="secno">4.5</span> <span class="content">Trivially relocatable type [basic.types.general]</span></a>
      <li><a href="#wording-dcl.attr.trivreloc"><span class="secno">4.6</span> <span class="content"><code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> attribute [dcl.attr.trivreloc]</span></a>
      <li><a href="#wording-meta.unary.prop"><span class="secno">4.7</span> <span class="content">Type traits <code class="highlight"><c- n>is_relocatable</c-></code> etc. [meta.unary.prop]</span></a>
      <li><a href="#wording-concept.relocatable"><span class="secno">4.8</span> <span class="content"><code class="highlight"><c- n>relocatable</c-></code> concept [concept.relocatable]</span></a>
     </ol>
    <li>
     <a href="#alternatives"><span class="secno">5</span> <span class="content">Rationale and alternatives</span></a>
     <ol class="toc">
      <li><a href="#maybe-trivially-relocatable"><span class="secno">5.1</span> <span class="content">Attribute <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code></span></a>
      <li><a href="#pmr-concerns"><span class="secno">5.2</span> <span class="content">Confusing interactions with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-></code></span></a>
      <li><a href="#overlap-concerns"><span class="secno">5.3</span> <span class="content">Overlapping base-class subobjects</span></a>
     </ol>
    <li><a href="#acknowledgements"><span class="secno">6</span> <span class="content">Acknowledgements</span></a>
    <li>
     <a href="#polls"><span class="secno"></span> <span class="content">Appendix A: Straw polls</span></a>
     <ol class="toc">
      <li><a href="#taken-polls-2023-02-10"><span class="secno"></span> <span class="content">Polls taken at EWGI at Issaquah on 2023-02-10</span></a>
      <li><a href="#taken-polls-2020-02-13"><span class="secno"></span> <span class="content">Polls taken at EWGI at Prague on 2020-02-13</span></a>
     </ol>
    <li><a href="#samples"><span class="secno"></span> <span class="content">Appendix B: Sample code</span></a>
    <li>
     <a href="#non-trivial-samples"><span class="secno"></span> <span class="content">Appendix C: Examples of non-trivially relocatable class types</span></a>
     <ol class="toc">
      <li><a href="#non-trivial-sample-string"><span class="secno"></span> <span class="content">Class contains pointer to self</span></a>
      <li><a href="#non-trivial-sample-list"><span class="secno"></span> <span class="content">Allocated memory contains pointer to self</span></a>
      <li><a href="#non-trivial-sample-offset-ptr"><span class="secno"></span> <span class="content">Class invariant depends on <code class="highlight"><c- k>this</c-></code></span></a>
      <li><a href="#non-trivial-sample-registry"><span class="secno"></span> <span class="content">Program invariant depends on <code class="highlight"><c- k>this</c-></code></span></a>
      <li><a href="#non-trivial-sample-polymorphic"><span class="secno"></span> <span class="content">Polymorphic downcast effectively relies on offset-into-self</span></a>
     </ol>
    <li><a href="#implementation"><span class="secno"></span> <span class="content">Appendix D: Implementation experience</span></a>
    <li><a href="#open-questions"><span class="secno"></span> <span class="content">Appendix E: Open questions</span></a>
    <li>
     <a href="#index"><span class="secno"></span> <span class="content">Index</span></a>
     <ol class="toc">
      <li><a href="#index-defined-here"><span class="secno"></span> <span class="content">Terms defined by this specification</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#normative"><span class="secno"></span> <span class="content">Normative References</span></a>
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
    <li><a href="#issues-index"><span class="secno"></span> <span class="content">Issues Index</span></a>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="changelog"><span class="secno">1. </span><span class="content">Changelog</span><a class="self-link" href="#changelog"></a></h2>
   <ul>
    <li data-md>
     <p>R7 (post-Issaquah 2023):</p>
     <ul>
      <li data-md>
       <p><a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> debuted at Issaquah; it raised several
    open questions (see <a href="#open-questions">Appendix E: Open questions</a>). The authors of P1144 and P2786
    plan a joint paper to resolve some of these design issues.</p>
      <li data-md>
       <p>Added <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate_backward</c-></code>, the building block of <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code>.</p>
      <li data-md>
       <p>Removed "move-constructible, destructible" from the requirements in <a href="#wording-basic.types.general">basic.types.general</a>.
    Now trivially relocatable types, like trivially copyable types, can be non-relocatable.</p>
      <li data-md>
       <p>Added <a href="#applications">table §2.1</a> directly comparing this proposal to Folly, BSL, and Qt.</p>
      <li data-md>
       <p>Added straw poll results from Issaquah; removed much background and discussion
    (leaving only references for the interested reader to consult <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a>).</p>
      <li data-md>
       <p>Jonathan Hopkins points out that (contrary to the English description in <a data-link-type="biblio" href="#biblio-n2271" title="N2271: EASTL — Electronic Arts Standard Template Library">[N2271]</a>)
    EASTL defines <code class="highlight"><c- n>has_trivial_relocate</c-></code> as a synonym for <code class="highlight"><c- n>is_trivially_move_assignable</c-></code>, thus it’s not prior art for this notion.
    (In particular, EASTL considers <code class="highlight"><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> non-trivially relocatable.)
    Remove mentions of EASTL.</p>
      <li data-md>
       <p>Added <a href="#open-questions">Appendix E</a>.</p>
     </ul>
    <li data-md>
     <p>R6:</p>
     <ul>
      <li data-md>
       <p>Added <code class="highlight"><c- n>T</c-> <c- n>std</c-><c- o>::</c-><c- n>relocate</c-><c- p>(</c-><c- n>T</c-> <c- o>*</c-><c- n>source</c-><c- p>)</c-></code>.</p>
      <li data-md>
       <p>Changed the exception guarantee of <code class="highlight"><c- n>uninitialized_relocate</c-></code> and <code class="highlight"><c- n>uninitialized_relocate_n</c-></code> in accord with feedback from David Stone.</p>
      <li data-md>
       <p>Removed <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>relocate_at</c-></code> (but kept <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-></code>).</p>
     </ul>
    <li data-md>
     <p>R5 (post-Prague 2020):</p>
     <ul>
      <li data-md>
       <p>Polymorphic types (those with any vptr at all) inhibit "natural" trivial relocatability.
    David Stone gave the motivating example. See <a href="#non-trivial-sample-polymorphic">Polymorphic downcast effectively relies on offset-into-self</a>.</p>
      <li data-md>
       <p>Updated <code class="highlight"><c- k>concept</c-> <c- nc>relocatable</c-></code>. Added semantic requirements on assignment and some discussion
    of the issue with <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code>.</p>
     </ul>
    <li data-md>
     <p>R3 (post-Kona 2019):</p>
     <ul>
      <li data-md>
       <p>User-provided copy constructors and copy/move assignment operators inhibit "natural" trivial relocatability.
    This permits optimizing <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code> and <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code>.</p>
      <li data-md>
       <p>Adopted <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>(</c-><c- b>bool</c-><c- p>)]]</c-></code>.</p>
      <li data-md>
       <p>Added <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-><c- p>(</c-><c- n>source</c-><c- p>,</c-> <c- n>dest</c-><c- p>)</c-></code>.</p>
      <li data-md>
       <p>Removed the core-language blanket wording that permitted "the implementation" to eliminate
    moves and destroys of trivially relocatable types. Instead, the existence of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-></code> and handwaviness of e.g. <a href="http://eel.is/c++draft/vector#capacity-4"> [vector.capacity</a>] combine to strongly imply
    (but still not to mandate) that library vendors will use <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-></code> wherever
    it helps with performance. We no longer propose to permit eliminating
    moves and destroys in e.g. <code class="highlight"><c- k>return</c-></code> statements, except as already permitted under the as-if rule.</p>
     </ul>
   </ul>
   <h2 class="heading settled" data-level="2" id="intro"><span class="secno">2. </span><span class="content">Introduction and motivation</span><a class="self-link" href="#intro"></a></h2>
   <p>Given an object type <code class="highlight"><c- n>T</c-></code> and memory addresses <code class="highlight"><c- n>src</c-></code> and <code class="highlight"><c- n>dst</c-></code>,
the phrase "<b><i>relocate</i></b> a <code class="highlight"><c- n>T</c-></code> from <code class="highlight"><c- n>src</c-></code> to <code class="highlight"><c- n>dst</c-></code>" means
"<em>move-construct</em> <code class="highlight"><c- n>dst</c-></code> from <code class="highlight"><c- n>src</c-></code>, and then immediately <em>destroy</em> the object at <code class="highlight"><c- n>src</c-></code>."</p>
   <p>Any type which is both move-constructible and destructible is <b><i>relocatable</i></b>.
A type is <b><i>nothrow relocatable</i></b> if its relocation operation is noexcept, and a type
is <b><i><a data-link-type="abstract-op" href="#abstract-opdef-trivially-relocatable" id="ref-for-abstract-opdef-trivially-relocatable">trivially relocatable</a></i></b> if its relocation operation is trivial (which,
just like trivial move-construction and trivial copy-construction, means
"tantamount to <code class="highlight"><c- n>memcpy</c-></code>").</p>
   <p>In practice, almost all relocatable types are trivially relocatable: <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> (on libc++), <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> (on MSVC).
Examples of non-trivially relocatable types include <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> (on libstdc++ and libc++), <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> (on libstdc++ and MSVC), <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-></code> (everywhere). See <a href="#non-trivial-samples">Appendix C: Examples of non-trivially relocatable class types</a>.</p>
   <p>P1144 allows the library programmer
to <b><i>warrant</i></b> to the compiler that a resource-management type is trivially relocatable.
Explicit warrants are rarely needed because the compiler can infer trivial relocatability for
Rule-of-Zero types. See <a href="#wording-basic.types.general">§ 4.5 Trivially relocatable type [basic.types.general]</a>.</p>
   <p>The most important thing about P1144 relocation is that it is backward compatible and does not
break either API or ABI. My intention is simply to legalize the well-understood tricks
that many industry codebases (<a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, <a data-link-type="biblio" href="#biblio-deque" title="Improve relocation ... (__is_trivially_relocatable): Specialize for deque">[Deque]</a>) are already doing in practice.
P1144 is not intended to change the behavior of any existing source code (except to speed it up),
nor does it require major work from standard library vendors.</p>
   <h3 class="heading settled" data-level="2.1" id="applications"><span class="secno">2.1. </span><span class="content">Optimizations enabled by trivial relocatability</span><a class="self-link" href="#applications"></a></h3>
   <p>The following optimizations are possible according to P1144R7’s notion of
trivial relocatability. Here’s who does these optimizations in practice:</p>
   <table>
    <tbody>
     <tr>
      <td>
      <td> vector realloc 
      <td> type erasure 
      <td> fixed-cap move 
      <td> vector <code class="highlight"><c- n>erase</c-></code> 
      <td> vector <code class="highlight"><c- n>insert</c-></code> 
      <td> <code class="highlight"><c- n>rotate</c-></code> 
      <td> <code class="highlight"><c- n>swap</c-></code> 
     <tr>
      <td> Arthur’s libc++ <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/d0c5d3639e/libcxx/include/vector#L936-L942"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-></code></a> 
      <td> no 
      <td> N/A 
      <td> not yet 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/d0c5d3639e/libcxx/include/vector#L1728-L1744"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-></code></a> 
      <td> yes, uses <code class="highlight"><c- n>swap</c-></code> 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/d0c5d3639e/libcxx/include/__utility/swap.h#L45-L57"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code></a> 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a> <code class="highlight"><c- n>bslmf</c-><c- o>::</c-><c- n>IsBitwiseMoveable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslstl/bslstl_vector.h#L3374-L3398"><code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>vector</c-></code></a> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslstl/bslstl_function.h#L116-L131">no</a> 
      <td> ? 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L3769-L3800"><code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>vector</c-></code></a> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L3606-L3643"><code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>vector</c-></code></a> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L1707-L1722"><code class="highlight"><c- n>ArrayPrimitives_Imp</c-><c- o>::</c-><c- n>rotate</c-></code></a>, unused by <code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>rotate</c-></code> 
      <td> no 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a> <code class="highlight"><c- n>folly</c-><c- o>::</c-><c- n>IsRelocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L945-L966"><code class="highlight"><c- n>fbvector</c-></code></a> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/Function.h#L749-L755">no</a> 
      <td> <a href="https://github.com/facebook/folly/pull/1934">proposed</a> for <code class="highlight"><c- n>small_vector</c-></code> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L1232-L1259"><code class="highlight"><c- n>fbvector</c-></code></a> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L1273-L1292"><code class="highlight"><c- n>fbvector</c-></code></a> 
      <td> N/A 
      <td> N/A 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a> <code class="highlight"><c- n>QTypeInfo</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>isRelocatable</c-></code> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L865-L872"><code class="highlight"><c- n>QList</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/kernel/qvariant.h#L73-L94"><code class="highlight"><c- n>QVariant</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qvarlengtharray.h#L312-L328"><code class="highlight"><c- n>QVarLengthArray</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L842-L863"><code class="highlight"><c- n>QList</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L679-L730"><code class="highlight"><c- n>QList</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/7db28fb/src/corelib/tools/qcontainertools_impl.h#L89-L107"><code class="highlight"><c- n>q_rotate</c-></code></a> 
      <td> N/A 
   </table>
   <h4 class="heading settled" data-level="2.1.1" id="benefit-resize"><span class="secno">2.1.1. </span><span class="content">Contiguous reallocation</span><a class="self-link" href="#benefit-resize"></a></h4>
   <p>Trivial relocation can be used anywhere we do the moral equivalent of <code class="highlight"><c- n>realloc</c-></code>,
such as in <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>::</c-><c- n>reserve</c-></code>.</p>
   <p><a data-link-type="biblio" href="#biblio-bench" title="Benchmark code from &quot;The Best Type Traits C++ Doesn&apos;t Have&quot;">[Bench]</a> (presented at C++Now 2018) shows a 3x speedup on <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>>::</c-><c- n>resize</c-></code>. <a href="https://www.reddit.com/r/cpp/comments/9wj4vt/trivially_relocatable_in_san_diego_call_for/e9p76i4/">This Reddit thread</a> demonstrates a similar 3x speedup using the online tool Quick-Bench.</p>
   <h4 class="heading settled" data-level="2.1.2" id="benefit-type-erasure"><span class="secno">2.1.2. </span><span class="content">Moving in-place/SBO type-erased types like <code class="highlight"><c- n>any</c-></code> and <code class="highlight"><c- n>function</c-></code></span><a class="self-link" href="#benefit-type-erasure"></a></h4>
   <p>Trivial relocation can be used to de-duplicate the code generated by type-erasing wrappers
like <code class="highlight"><c- n>any</c-></code>, <code class="highlight"><c- n>function</c-></code>, and <code class="highlight"><c- n>move_only_function</c-></code>.
For these types, a <em>move</em> of the wrapper object is implemented in terms of a <em>relocation</em> of the contained object. (See for example <a href="https://github.com/llvm-mirror/libcxx/blob/8fdc4918/include/any#L389-L394">libc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>any</c-></code></a>.)
In general, the <em>relocate</em> operation must be uniquely codegenned for each
different contained type <code class="highlight"><c- n>C</c-></code>, leading to code bloat. But a single instantiation suffices to relocate every <em>trivially</em> relocatable <code class="highlight"><c- n>C</c-></code> in the program.</p>
   <h4 class="heading settled" data-level="2.1.3" id="benefit-fixed-capacity"><span class="secno">2.1.3. </span><span class="content">Moving fixed-capacity containers like <code class="highlight"><c- n>static_vector</c-></code> and <code class="highlight"><c- n>small_vector</c-></code></span><a class="self-link" href="#benefit-fixed-capacity"></a></h4>
   <p>The move-constructor of <code class="highlight"><c- n>fixed_capacity_vector</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-><c- n>N</c-><c- o>></c-></code>,
can be implemented naïvely as an element-by-element <em>move</em> (leaving the source vector’s elements in their moved-from state),
or efficiently as an element-by-element <em>relocate</em> (leaving the source vector empty).</p>
   <p>For a detailed analysis of this case, see <a data-link-type="biblio" href="#biblio-fixedcapacityvector" title="P1144 case study: Moving a `fixed_capacity_vector`">[FixedCapacityVector]</a>.</p>
   <p><code class="highlight"><c- n>boost</c-><c- o>::</c-><c- n>container</c-><c- o>::</c-><c- n>static_vector</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-><c- n>N</c-><c- o>></c-></code> currently implements the
naïve element-by-element-move strategy, but after LEWG feedback, <a data-link-type="biblio" href="#biblio-p0843r5" title="static_vector">[P0843R5]</a> <code class="highlight"><c- n>static_vector</c-></code> does <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html#Move-semantics">permit</a> the faster relocation strategy.</p>
   <h4 class="heading settled" data-level="2.1.4" id="benefit-insert-erase"><span class="secno">2.1.4. </span><span class="content">Contiguous insert and erase</span><a class="self-link" href="#benefit-insert-erase"></a></h4>
   <p>Trivial relocation can be used anywhere we shift a contiguous range left or right,
such as in <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code> (i.e., destroy the erased elements and "close the window"
by memmoving left) and <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code> (i.e., "make a window" by memmoving right and
then construct the new elements in place). <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>'s <code class="highlight"><c- n>fbvector</c-></code> is prior art
for this optimization; see <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L1273-L1308"><code class="highlight"><c- n>fbvector</c-><c- o>::</c-><c- n>make_window</c-></code></a>.</p>
   <p><a href="#pmr-concerns">§ 5.2 Confusing interactions with std::pmr</a> determines whether this optimization will be possible in Standard C++.</p>
   <h4 class="heading settled" data-level="2.1.5" id="benefit-swap"><span class="secno">2.1.5. </span><span class="content">Swap</span><a class="self-link" href="#benefit-swap"></a></h4>
   <p>Given a reliable way of detecting trivial relocatability,
we can optimize any routine that uses the moral equivalent of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code>, such as <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>partition</c-></code>, or <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>sort</c-></code>.</p>
   <p>Optimizing <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code> produces massive code-size improvements for all swap-based
algorithms, including <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>sort</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code>. 
See <a href="https://www.youtube.com/watch?v=SGdfPextuAU&amp;t=19m56s">@19:56–21:22</a> in my C++Now 2019 talk,
and see <a href="https://p1144.godbolt.org/z/PPYhcYd8d">this Godbolt</a>. <a href="https://quick-bench.com/q/suAss7ElmwgLDbOJQGnlEseheSQ">This Quick-Bench</a> shows a 25% speedup
in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> when it is allowed to use bitwise swap on a Rule-of-Zero type.</p>
   <p>But <a href="#pmr-concerns">§ 5.2 Confusing interactions with std::pmr</a> determines whether this optimization will be possible in Standard C++.</p>
   <h3 class="heading settled" data-level="2.2" id="benefit-assertions"><span class="secno">2.2. </span><span class="content">Assertions, not assumptions</span><a class="self-link" href="#benefit-assertions"></a></h3>
   <p>Some data structures might reasonably assert the trivial relocatability of
their elements, just as they sometimes assert the stronger property of trivial <em>copyability</em> today.
This might help them guarantee reasonable performance, or guarantee exception-safety.</p>
   <h3 class="heading settled" data-level="2.3" id="doing-it-wrong"><span class="secno">2.3. </span><span class="content">Eliminate manual warrants, improve safety</span><a class="self-link" href="#doing-it-wrong"></a></h3>
   <p>Many real-world codebases contain templates which require
trivial relocatability of their template parameters, but cannot today <em>verify</em> trivial relocatability. For example, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a> requires the programmer to warrant the trivial
relocatability of any type stored in a <code class="highlight"><c- n>folly</c-><c- o>::</c-><c- n>fbvector</c-></code>:</p>
<pre class="language-c++ highlight"><c- n>class</c-> <c- n>Widget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->

<c- n>folly</c-><c- o>::</c-><c- n>fbvector</c-><c- o>&lt;</c-><c- n>Widget</c-><c- o>></c-> <c- n>vec</c-><c- p>;</c->  <c- c1>// FAILS AT COMPILE TIME for lack of warrant</c->
</pre>
   <p>This merely encourages the programmer to add the warrant and continue. An incorrect
warrant will be discovered only at runtime, via undefined behavior. See <a href="#non-trivial-sample-list">Allocated memory contains pointer to self</a>, <a data-link-type="biblio" href="#biblio-follyissue889" title="Traits.h marks std::list as trivially relocatable, but in fact it is not">[FollyIssue889]</a>, and (most importantly) <a href="https://www.youtube.com/watch?v=SGdfPextuAU&amp;t=27m26s">@27:26–31:47</a> in my C++Now 2019 talk.</p>
<pre class="language-c++ highlight"><c- n>class</c-> <c- n>Gadget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->
<c- c1>// sigh, add the warrant on autopilot</c->
<c- n>template</c-><c- o>&lt;></c-> <c- k>struct</c-> <c- nc>folly</c-><c- o>::</c-><c- n>IsRelocatable</c-><c- o>&lt;</c-><c- n>Gadget</c-><c- o>></c-> <c- o>:</c-> <c- n>std</c-><c- o>::</c-><c- n>true_type</c-> <c- p>{};</c->

<c- n>folly</c-><c- o>::</c-><c- n>fbvector</c-><c- o>&lt;</c-><c- n>Gadget</c-><c- o>></c-> <c- n>vec</c-><c- p>;</c->  <c- c1>// CRASHES AT RUNTIME due to fraudulent warrant</c->
</pre>
   <p>If this proposal is adopted, then Folly can start using <code class="highlight"><c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>)</c-></code> in the implementation of <code class="highlight"><c- n>fbvector</c-></code>, and the programmer can stop writing explicit warrants.
Finally, the programmer can start writing assertions of correctness, which aids maintainability and
can even find real bugs. <a href="https://p1144.godbolt.org/z/7b8893sjr">Example:</a></p>
<pre class="language-c++ highlight"><c- n>class</c-> <c- n>Widget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Widget</c-><c- o>></c-><c- p>);</c->  <c- c1>// correctly SUCCEEDS</c->

<c- n>class</c-> <c- n>Gadget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Gadget</c-><c- o>></c-><c- p>);</c->  <c- c1>// correctly ERRORS</c->
</pre>
   <p>The improvement in user experience and safety in real-world codebases (<a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>, <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, etc.)
is the most important benefit to be gained by this proposal.</p>
   <h2 class="heading settled" data-level="3" id="design-goals"><span class="secno">3. </span><span class="content">Design goals</span><a class="self-link" href="#design-goals"></a></h2>
   <p>Every C++ type already <em>is</em> or <em>is not</em> trivially relocatable. This proposal does not require any
library vendor to make any library type trivially relocatable. (We assume that quality implementations
will do so on their own.)</p>
   <p>The optimizations above are in the domain of library writers. If you’re writing
a vector, and you detect that your element type <code class="highlight"><c- n>T</c-></code> is trivially relocatable, then
whether you optimize in that case is up to you.
This proposal does not require any library vendor to guarantee that any particular optimization
happens. (We assume that quality implementations will do so on their own.)</p>
   <p>What C++ lacks is a standard way for library writers to <em>detect</em> the (existing) trivial relocatability
of a type <code class="highlight"><c- n>T</c-></code>, so that they can reliably apply their (existing) optimizations.
All we really need is to add <em>detection</em>, and then all the optimizations described above will naturally
emerge without any further special effort by WG21.</p>
   <p>There are three kinds of object types that we want to make sure are correctly detected as
trivially relocatable. These three cases are important for improving the performance of
the standard library, and for improving the correctness of libraries such as <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>'s <code class="highlight"><c- n>fbvector</c-></code>.</p>
   <h3 class="heading settled" data-level="3.1" id="use1"><span class="secno">3.1. </span><span class="content">Standard library types such as <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code></span><a class="self-link" href="#use1"></a></h3>
   <p>In order to optimize <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>>::</c-><c- n>resize</c-></code>, we must come up with a way to achieve</p>
<pre class="language-c++ highlight"><c- cp>#include</c-> &lt;string>
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-> <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- o>></c-><c- p>);</c->
</pre>
   This could be done unilaterally by the library vendor — via a non-standard attribute
(<code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code>), or a member typedef with a reserved name,
or simply a vendor-provided specialization of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>></c-></code>. 
   <p>That is, we can in principle solve §3.1 while confining our "magic" to the headers
of the implementation itself. The programmer doesn’t have to learn anything new, so far.</p>
   <h3 class="heading settled" data-level="3.2" id="use2"><span class="secno">3.2. </span><span class="content">Program-defined types that follow the Rule of Zero</span><a class="self-link" href="#use2"></a></h3>
   <p>In order to optimize the SBO <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>function</c-></code> in any meaningful sense,
we must come up with a way to achieve</p>
<pre class="language-c++ highlight"><c- cp>#include</c-> &lt;string>
<c- k>auto</c-> <c- n>lam2</c-> <c- o>=</c-> <c- p>[</c-><c- n>x</c-><c- o>=</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- p>(</c-><c- s>"hello"</c-><c- p>)]{};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-> <c- n>decltype</c-><c- p>(</c-><c- n>lam2</c-><c- p>)</c-> <c- o>></c-><c- p>);</c->
</pre>
   Lambdas are not a special case in C++; they are simply class types with all their special members defaulted.
Therefore, lambdas can use the same solution as 
<pre class="language-c++ highlight"><c- cp>#include</c-> &lt;string>
<c- k>struct</c-> <c- nc>A</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>string</c-> <c- n>s</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-> <c- n>A</c-> <c- o>></c-><c- p>);</c->
</pre>
   Here <code class="highlight"><c- k>struct</c-> <c- nc>A</c-></code> follows the Rule of Zero: its move-constructor and destructor are both defaulted.
If they were also <em>trivial</em>, then we’d be done. In fact they are non-trivial; and yet, because the type’s
bases and members are all of trivially relocatable types, the type as a whole <em>is</em> trivially relocatable. 
   <p>§3.2 asks that we make the <code class="highlight"><c- k>static_assert</c-></code> succeed without breaking the "Rule of Zero."
We do not want to require the programmer to annotate <code class="highlight"><c- k>struct</c-> <c- nc>A</c-></code> with a special attribute, or
a special member typedef, or anything like that. We want it to Just Work.
This is a harder problem than §3.1; it requires standard support in the core language.
But it still does not require any new <em>syntax</em>.</p>
   <h3 class="heading settled" data-level="3.3" id="use3"><span class="secno">3.3. </span><span class="content">Program-defined types with non-defaulted special members</span><a class="self-link" href="#use3"></a></h3>
   <p>In order to optimize <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>boost</c-><c- o>::</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>>::</c-><c- n>resize</c-></code>,
we must come up with a way to achieve</p>
<pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>B</c-> <c- p>{</c->
    <c- n>B</c-><c- p>(</c-><c- n>B</c-><c- o>&amp;&amp;</c-><c- p>);</c->  <c- c1>// non-trivial</c->
    <c- o>~</c-><c- n>B</c-><c- p>();</c->  <c- c1>// non-trivial</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-> <c- n>B</c-> <c- o>></c-><c- p>);</c->
</pre>
   via some standard annotation applied to class type <code class="highlight"><c- n>B</c-></code> (which in this example is standing in for <code class="highlight"><c- n>boost</c-><c- o>::</c-><c- n>shared_ptr</c-></code>).
We cannot possibly do it without annotation, because there exist
examples of types that look just like <code class="highlight"><c- n>B</c-></code> and <em>are</em> trivially relocatable
(e.g. <a href="https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/std_function.h">libstdc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>function</c-></code></a>)
and there exist types that look just like <code class="highlight"><c- n>B</c-></code> and are <em>not</em> trivially relocatable
(e.g. <a href="https://github.com/llvm-mirror/libcxx/blob/4e7ffcaa/include/functional#L1719-L1734">libc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>function</c-></code></a>).
So, without some kind of opt-in annotation, we cannot achieve our goal. 
   <p>This paper proposes a standard syntax for §3.3, which in turn
provides a <em>simple and portable</em> way for library vendors to implement §3.1.</p>
   <h2 class="heading settled" data-level="4" id="wording"><span class="secno">4. </span><span class="content">Proposed wording for C++2b</span><a class="self-link" href="#wording"></a></h2>
   <p>The wording in this section is relative to <a data-link-type="biblio" href="#biblio-n4910" title="Working Draft, Standard for Programming Language C++">WG21 draft N4910</a>.</p>
   <p class="note" role="note"><span class="marker">Note:</span> There is no difficulty in changing the attribute syntax to a contextual-keyword syntax;
the only downsides are aesthetic. We can defer that decision to the last minute, according
to CWG’s feedback on the final wording.</p>
   <h3 class="heading settled" data-level="4.1" id="wording-algorithms.requirements"><span class="secno">4.1. </span><span class="content">Nothrow bidirectional iterator [algorithms.requirements]</span><a class="self-link" href="#wording-algorithms.requirements"></a></h3>
   <p>Modify <a href="https://eel.is/c++draft/algorithms.requirements">[algorithms.requirements]</a> as follows:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ul><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>ForwardIterator</c-></code>, <code class="highlight"><c- n>ForwardIterator1</c-></code>, <code class="highlight"><c- n>ForwardIterator2</c-></code>, or <code class="highlight"><c- n>NoThrowForwardIterator</c-></code>,
the template argument shall meet the <em>Cpp17ForwardIterator</em> requirements ([forward.iterators]) if it is required to be a mutable iterator,
or model <code class="highlight"><c- n>forward_iterator</c-></code> ([iterator.concept.forward]) otherwise.</p> </li><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>NoThrowForwardIterator</c-></code>, the template argument is also required to have the property
that no exceptions are thrown from increment, assignment, or comparison of, or indirection through, valid iterators.</p> </li><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>BidirectionalIterator</c-></code>, <code class="highlight"><c- n>BidirectionalIterator1</c-></code>, <del>or</del> <code class="highlight"><c- n>BidirectionalIterator2</c-></code>, <ins>or <code class="highlight"><c- n>NoThrowBidirectionalIterator</c-></code>,</ins> the template argument shall meet the <em>Cpp17BidirectionalIterator</em> requirements ([bidirectional.iterators])
if it is required to be a mutable iterator, or model <code class="highlight"><c- n>bidirectional_iterator</c-></code> ([iterator.concept.bidir]) otherwise.</p> </li><li data-md><ins>If an algorithm’s template parameter is named <code class="highlight"><c- n>NoThrowBidirectionalIterator</c-></code>, the template argument is also required to have the property
that no exceptions are thrown from increment, decrement, assignment, or comparison of, or indirection through, valid iterators.</ins> </li></ul> </small>
   </blockquote>
   <h3 class="heading settled" data-level="4.2" id="wording-defns.relocation"><span class="secno">4.2. </span><span class="content">Relocation operation [defns.relocation]</span><a class="self-link" href="#wording-defns.relocation"></a></h3>
   <p>Add a new section in <a href="http://eel.is/c++draft/definitions">[intro.defs]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <dl><dt data-md><dfn class="dfn-paneled" data-dfn-type="abstract-op" data-export id="abstract-opdef-relocation-operation">relocation operation</dfn></dt><dd data-md><p>the homogeneous binary operation performed by <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-></code>, consisting of a move construction immediately followed by a destruction of the source object</p> </dd></dl> </small>
   </blockquote>
   <h3 class="heading settled" data-level="4.3" id="wording-relocate"><span class="secno">4.3. </span><span class="content"><code class="highlight"><c- n>relocate_at</c-></code> and <code class="highlight"><c- n>relocate</c-></code> [specialized.relocate]</span><a class="self-link" href="#wording-relocate"></a></h3>
   <p>Add a new section after <a href="http://eel.is/c++draft/specialized.destroy">[specialized.destroy]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
<c- n>T</c-> <c- o>*</c-><c- n>relocate_at</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-> <c- n>source</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-> <c- n>dest</c-><c- p>);</c->
</pre> <p><em>Mandates:</em> <code class="highlight"><c- n>T</c-></code> shall be a complete non-array object type.</p> <p><em>Effects:</em> Equivalent to:</p> <pre class="highlight"><c- k>struct</c-> <c- nc>guard</c-> <c- p>{</c-> <c- n>T</c-> <c- o>*</c-><c- n>t</c-><c- p>;</c-> <c- o>~</c-><c- n>guard</c-><c- p>()</c-> <c- p>{</c-> <c- n>destroy_at</c-><c- p>(</c-><c- n>t</c-><c- p>);</c-> <c- p>}</c-> <c- p>}</c-> <c- n>g</c-><c- p>(</c-><c- n>source</c-><c- p>);</c->
<c- k>return</c-> <c- o>::</c-><c- k>new</c-> <c- p>(</c-><c- n>voidify</c-><c- p>(</c-><c- o>*</c-><c- n>dest</c-><c- p>))</c-> <c- n>T</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>source</c-><c- p>));</c->
</pre><p>except that if <code class="highlight"><c- n>T</c-></code> is trivially relocatable <i>[basic.types]</i>, side effects
associated with the relocation of the value of <code class="highlight"><c- o>*</c-><c- n>source</c-></code> might not happen.</p> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
<c- n>T</c-> <c- n>relocate</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-> <c- n>source</c-><c- p>);</c->
</pre> <p><em>Mandates:</em> <code class="highlight"><c- n>T</c-></code> shall be a complete non-array object type.</p> <p><em>Effects:</em> Equivalent to:</p> <pre class="highlight"><c- n>T</c-> <c- n>t</c-> <c- o>=</c-> <c- n>move</c-><c- p>(</c-><c- n>source</c-><c- p>);</c->
<c- n>destroy_at</c-><c- p>(</c-><c- n>source</c-><c- p>);</c->
<c- k>return</c-> <c- n>t</c-><c- p>;</c->
</pre><p>except that if <code class="highlight"><c- n>T</c-></code> is trivially relocatable <i>[basic.types]</i>, side effects
associated with the relocation of the object’s value might not happen.</p> </small>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> These functions have both been implemented in my libc++ fork; for <code class="highlight"><c- n>relocate</c-></code>, see <a href="https://p1144.godbolt.org/z/cqPP4oeE9">godbolt.org/z/cqPP4oeE9</a> and <a data-link-type="biblio" href="#biblio-stdrelocateiscute" title="std::relocate&apos;s implementation is cute">[StdRelocateIsCute]</a>. My implementation of their "as-if-by-memcpy" codepaths relies on
Clang’s <code class="highlight"><c- n>__builtin_memcpy</c-></code>; vendors can use any vendor-specific means to implement them.
The wording also deliberately permits a low-quality implementation with no such codepath at all.
See <a href="https://www.youtube.com/watch?v=SGdfPextuAU&amp;t=45m23s">@45:23–48:39</a> in my C++Now 2019 talk.</p>
   <h3 class="heading settled" data-level="4.4" id="wording-uninitialized.relocate"><span class="secno">4.4. </span><span class="content"><code class="highlight"><c- n>uninitialized_relocate</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_n</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_backward</c-></code> [uninitialized.relocate]</span><a class="self-link" href="#wording-uninitialized.relocate"></a></h3>
   <p>Add a new section after <a href="http://eel.is/c++draft/uninitialized.move">[uninitialized.move]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>InputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c->
<c- n>NoThrowForwardIterator</c-> <c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>InputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>InputIterator</c-> <c- n>last</c-><c- p>,</c->
                                              <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c->
</pre> <p><em>Effects:</em> Equivalent to:</p> <pre class="highlight"><c- k>try</c-> <c- p>{</c->
  <c- k>for</c-> <c- p>(;</c-> <c- n>first</c-> <c- o>!=</c-> <c- n>last</c-><c- p>;</c-> <c- o>++</c-><c- n>result</c-><c- p>,</c-> <c- p>(</c-><c- b>void</c-><c- p>)</c-><c- o>++</c-><c- n>first</c-><c- p>)</c-> <c- p>{</c->
    <c- o>::</c-><c- k>new</c-> <c- p>(</c-><c- n>voidify</c-><c- p>(</c-><c- o>*</c-><c- n>result</c-><c- p>))</c->
      <c- k>typename</c-> <c- nc>iterator_traits</c-><c- o>&lt;</c-><c- n>NoThrowForwardIterator</c-><c- o>>::</c-><c- n>value_type</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c->
    <c- n>destroy_at</c-><c- p>(</c-><c- n>addressof</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c->
  <c- p>}</c->
  <c- k>return</c-> <c- n>result</c-><c- p>;</c->
<c- p>}</c-> <c- k>catch</c-> <c- p>(...)</c-> <c- p>{</c->
  <c- n>destroy</c-><c- p>(</c-><c- o>++</c-><c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>);</c->
  <c- k>throw</c-><c- p>;</c->
<c- p>}</c->
</pre><p>except that if the iterators' common value type is trivially relocatable, side effects
associated with the relocation of the object’s value might not happen.</p> <p><em>Remarks:</em> If an exception is thrown, all objects in both the source and destination
ranges are destroyed.</p> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>InputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>InputIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c->
    <c- n>uninitialized_relocate_n</c-><c- p>(</c-><c- n>InputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>Size</c-> <c- n>n</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c->
</pre> <p><em>Effects:</em> Equivalent to:</p> <pre class="highlight"><c- k>try</c-> <c- p>{</c->
  <c- k>for</c-> <c- p>(;</c-> <c- n>n</c-> <c- o>></c-> <c- mi>0</c-><c- p>;</c-> <c- o>++</c-><c- n>result</c-><c- p>,</c-> <c- p>(</c-><c- b>void</c-><c- p>)</c-><c- o>++</c-><c- n>first</c-><c- p>,</c-> <c- o>--</c-><c- n>n</c-><c- p>)</c-> <c- p>{</c->
    <c- o>::</c-><c- k>new</c-> <c- p>(</c-><c- n>voidify</c-><c- p>(</c-><c- o>*</c-><c- n>result</c-><c- p>))</c->
      <c- k>typename</c-> <c- nc>iterator_traits</c-><c- o>&lt;</c-><c- n>NoThrowForwardIterator</c-><c- o>>::</c-><c- n>value_type</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c->
    <c- n>destroy_at</c-><c- p>(</c-><c- n>addressof</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c->
  <c- p>}</c->
  <c- k>return</c-> <c- p>{</c-><c- n>first</c-><c- p>,</c-> <c- n>result</c-><c- p>};</c->
<c- p>}</c-> <c- k>catch</c-> <c- p>(...)</c-> <c- p>{</c->
  <c- n>destroy_n</c-><c- p>(</c-><c- o>++</c-><c- n>first</c-><c- p>,</c-> <c- o>--</c-><c- n>n</c-><c- p>);</c->
  <c- k>throw</c-><c- p>;</c->
<c- p>}</c->
</pre><p>except that if the iterators' common value type is trivially relocatable, side effects
associated with the relocation of the object’s value might not happen.</p> <p><em>Remarks:</em> If an exception is thrown, all objects in both the source and destination
ranges are destroyed.</p> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>BidirectionalIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator</c-><c- o>></c->
  <c- n>NoThrowBidirectionalIterator</c->
    <c- n>uninitialized_relocate_backward</c-><c- p>(</c-><c- n>BidirectionalIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>BidirectionalIterator</c-> <c- n>last</c-><c- p>,</c->
                                    <c- n>NoThrowBidirectionalIterator</c-> <c- n>result</c-><c- p>);</c->
</pre> <p><em>Effects:</em> Equivalent to:</p> <pre class="highlight"><c- k>try</c-> <c- p>{</c->
  <c- k>for</c-> <c- p>(;</c-> <c- n>last</c-> <c- o>!=</c-> <c- n>first</c-><c- p>;</c-> <c- p>)</c-> <c- p>{</c->
    <c- o>--</c-><c- n>last</c-><c- p>;</c->
    <c- o>--</c-><c- n>result</c-><c- p>;</c->
    <c- o>::</c-><c- k>new</c-> <c- p>(</c-><c- n>voidify</c-><c- p>(</c-><c- o>*</c-><c- n>result</c-><c- p>))</c->
      <c- k>typename</c-> <c- nc>iterator_traits</c-><c- o>&lt;</c-><c- n>NoThrowBidirectionalIterator</c-><c- o>>::</c-><c- n>value_type</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>last</c-><c- p>));</c->
    <c- n>destroy_at</c-><c- p>(</c-><c- n>addressof</c-><c- p>(</c-><c- o>*</c-><c- n>last</c-><c- p>));</c->
  <c- p>}</c->
  <c- k>return</c-> <c- n>result</c-><c- p>;</c->
<c- p>}</c-> <c- k>catch</c-> <c- p>(...)</c-> <c- p>{</c->
  <c- n>destroy</c-><c- p>(</c-><c- n>first</c-><c- p>,</c-> <c- o>++</c-><c- n>last</c-><c- p>);</c->
  <c- k>throw</c-><c- p>;</c->
<c- p>}</c->
</pre><p>except that if the iterators' common value type is trivially relocatable, side effects
associated with the relocation of the object’s value might not happen.</p> <p><em>Remarks:</em> If an exception is thrown, all objects in both the source and destination
ranges are destroyed.</p> </small>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> The Remarks allude to blanket wording in <a href="http://eel.is/c++draft/specialized.algorithms#general-2">[specialized.algorithms.general]/2</a>.</p>
   <h3 class="heading settled" data-level="4.5" id="wording-basic.types.general"><span class="secno">4.5. </span><span class="content">Trivially relocatable type [basic.types.general]</span><a class="self-link" href="#wording-basic.types.general"></a></h3>
   <p>Add a new section in <a href="http://eel.is/c++draft/basic.types.general">[basic.types.general]</a>:</p>
   <p><small></small></p>
   <blockquote><small> An object type <code class="highlight"><c- n>T</c-></code> is a <dfn class="dfn-paneled" data-dfn-type="abstract-op" data-export id="abstract-opdef-trivially-relocatable">trivially relocatable</dfn> type if it is:<p></p> <ul><li data-md><p>a trivially copyable type, or</p> </li><li data-md><p>an array of trivially relocatable type, or</p> </li><li data-md><p>a (possibly cv-qualified) class type declared with a <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute
with value <code class="highlight">true</code> <a href="#wording-dcl.attr.trivreloc">[dcl.attr.trivreloc]</a>, or</p> </li><li data-md><p>a (possibly cv-qualified) class type which:</p> <ul><li data-md><p>has no user-provided move constructors or move assignment operators,</p> </li><li data-md><p>has no user-provided copy constructors or copy assignment operators,</p> </li><li data-md><p>has no user-provided destructors,</p> </li><li data-md><p>has no virtual member functions,</p> </li><li data-md><p>has no virtual base classes,</p> </li><li data-md><p>all of whose members are either of reference type or of trivially relocatable type, and</p> </li><li data-md><p>all of whose base classes are of trivially relocatable type.</p> </li></ul></li></ul> <p>[<em>Note:</em> For a trivially relocatable type, the <a data-link-type="abstract-op" href="#abstract-opdef-relocation-operation" id="ref-for-abstract-opdef-relocation-operation">relocation operation</a> (as performed by,
for example, the library functions <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>::</c-><c- n>resize</c-></code>) is tantamount
to a simple copy of the underlying bytes. <em>—end note</em>]</p> <p>[<em>Note:</em> It is intended that most standard library types be trivially relocatable types. <em>—end note</em>]</p> </small></blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> Polymorphic types are disallowed from "natural" trivial relocatability.
See <a href="#non-trivial-sample-polymorphic">Appendix C, example 5</a>.
Volatile members are not disallowed. See <a data-link-type="biblio" href="#biblio-subobjects" title="When is a trivially copyable object not trivially copyable?">[Subobjects]</a>.</p>
   <h3 class="heading settled" data-level="4.6" id="wording-dcl.attr.trivreloc"><span class="secno">4.6. </span><span class="content"><code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> attribute [dcl.attr.trivreloc]</span><a class="self-link" href="#wording-dcl.attr.trivreloc"></a></h3>
   <p>Add a new section after <a href="http://eel.is/c++draft/dcl.attr.nouniqueaddr">[dcl.attr.nouniqueaddr]</a>:</p>
   <p><small></small></p>
   <blockquote><small> The <em>attribute-token</em> <code class="highlight"><c- n>trivially_relocatable</c-></code> specifies that a class type’s relocation operation has no
visible side-effects other than a copy of the underlying bytes, as if by the library function <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>memcpy</c-></code>.
It may be applied to the definition of a class. It shall appear at most once in each <em>attribute-list</em>.
An <em>attribute-argument-clause</em> may be present and, if present, shall have the form<p></p> <pre class="highlight"><c- p>(</c-> <c- n>constant</c-><c- o>-</c-><c- n>expression</c-> <c- p>)</c->
</pre>The <em>constant-expression</em> shall be an integral constant expression of type <code class="highlight"><c- b>bool</c-></code>.
If no <em>attribute-argument-clause</em> is present, it has the same effect as an <em>attribute-argument-clause</em> of <code class="highlight"><c- p>(</c->true<c- p>)</c-></code>. <p>If any definition of a class type has a <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute with value <em>V</em>, then each
definition of the same class type shall have a <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute with value <em>V</em>.
No diagnostic is required if definitions in different translation units have
mismatched <code class="highlight"><c- n>trivially_relocatable</c-></code> attributes.</p> <p>If a type <code class="highlight"><c- n>T</c-></code> is declared with the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute, and <code class="highlight"><c- n>T</c-></code> is either not move-constructible
or not destructible, the program is ill-formed.</p> <p>If a class type is declared with the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute, and the program relies on
observable side-effects of its relocation other than a copy of the underlying bytes, the behavior is undefined.</p> </small></blockquote>
   <p class="issue" id="issue-20b76dab"><a class="self-link" href="#issue-20b76dab"></a> "If a type <code class="highlight"><c- n>T</c-></code> is declared with the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute, and <code class="highlight"><c- n>T</c-></code> is either not move-constructible
or not destructible, the program is ill-formed." We might want to replace this wording with
a mere "Note" <em>encouraging</em> implementations to diagnose.
See <a href="https://p1144.godbolt.org/z/ociAVX">this example</a> where a diagnostic might be unwanted.</p>
   <h3 class="heading settled" data-level="4.7" id="wording-meta.unary.prop"><span class="secno">4.7. </span><span class="content">Type traits <code class="highlight"><c- n>is_relocatable</c-></code> etc. [meta.unary.prop]</span><a class="self-link" href="#wording-meta.unary.prop"></a></h3>
   <p>Add new entries to Table 47 in <a href="http://eel.is/c++draft/meta.unary.prop">[meta.unary.prop]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <table> <tbody><tr><th>Template</th><th>Condition</th><th>Preconditions</th></tr> <tr> <td><code class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_relocatable</c-><c- p>;</c-></code></td> <td><code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>is_destructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code></td> <td>T shall be a complete type, <i>cv</i> <code class="highlight"><c- b>void</c-></code>, or an array of unknown bound.</td> </tr> <tr> <td><code class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_nothrow_relocatable</c-><c- p>;</c-></code></td> <td><code class="highlight"><c- n>is_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code> and both the indicated move-constructor and the destructor are known not to throw any exceptions.</td> <td>T shall be a complete type, <i>cv</i> <code class="highlight"><c- b>void</c-></code>, or an array of unknown bound.</td> </tr> <tr> <td><code class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_trivially_relocatable</c-><c- p>;</c-></code></td> <td><code class="highlight"><c- n>T</c-></code> is a <a data-link-type="abstract-op" href="#abstract-opdef-trivially-relocatable" id="ref-for-abstract-opdef-trivially-relocatable①">trivially relocatable</a> type.</td> <td>T shall be a complete type, <i>cv</i> <code class="highlight"><c- b>void</c-></code>, or an array of unknown bound.</td> </tr> </tbody></table> </small>
   </blockquote>
   <h3 class="heading settled" data-level="4.8" id="wording-concept.relocatable"><span class="secno">4.8. </span><span class="content"><code class="highlight"><c- n>relocatable</c-></code> concept [concept.relocatable]</span><a class="self-link" href="#wording-concept.relocatable"></a></h3>
   <p>Add a new section after <a href="http://eel.is/c++draft/concept.copyconstructible">[concept.copyconstructible]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>concept</c-> <c- nc>relocatable</c-> <c- o>=</c-> <c- n>move_constructible</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>;</c->
</pre> <p>If <code class="highlight"><c- n>T</c-></code> is an object type, then let <code class="highlight"><c- n>rv</c-></code> be an rvalue of type <code class="highlight"><c- n>T</c-></code>, <code class="highlight"><c- n>lv</c-></code> an lvalue of type <code class="highlight"><c- n>T</c-></code> equal to <code class="highlight"><c- n>rv</c-></code>,
and <code class="highlight"><c- n>u2</c-></code> a distinct object of type <code class="highlight"><c- n>T</c-></code> equal to <code class="highlight"><c- n>rv</c-></code>. <code class="highlight"><c- n>T</c-></code> models <code class="highlight"><c- n>relocatable</c-></code> only if</p> <ul><li data-md><p>After the definition <code class="highlight"><c- n>T</c-> <c- n>u</c-> <c- o>=</c-> <c- n>rv</c-><c- p>;</c-></code>, <code class="highlight"><c- n>u</c-></code> is equal to <code class="highlight"><c- n>u2</c-></code>.</p> </li><li data-md><p><code class="highlight"><c- n>T</c-><c- p>(</c-><c- n>rv</c-><c- p>)</c-></code> is equal to <code class="highlight"><c- n>u2</c-></code>.</p> </li><li data-md><p>If the expression <code class="highlight"><c- n>u2</c-> <c- o>=</c-> <c- n>rv</c-></code> is well-formed, then the expression has the same semantics as <code class="highlight"><c- n>u2</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>();</c-> <c- o>::</c-><c- k>new</c-> <c- p>((</c-><c- b>void</c-><c- o>*</c-><c- p>)</c-><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>u2</c-><c- p>))</c-> <c- n>T</c-><c- p>(</c-><c- n>rv</c-><c- p>);</c-></code></p> </li><li data-md><p>If the definition <code class="highlight"><c- n>T</c-> <c- n>u</c-> <c- o>=</c-> <c- n>lv</c-><c- p>;</c-></code> is well-formed, then after the definition <code class="highlight"><c- n>u</c-></code> is equal to <code class="highlight"><c- n>u2</c-></code>.</p> </li><li data-md><p>If the expression <code class="highlight"><c- n>T</c-><c- p>(</c-><c- n>lv</c-><c- p>)</c-></code> is well-formed, then the expression’s result is equal to <code class="highlight"><c- n>u2</c-></code>.</p> </li><li data-md><p>If the expression <code class="highlight"><c- n>u2</c-> <c- o>=</c-> <c- n>lv</c-></code> is well-formed, then the expression has the same semantics as <code class="highlight"><c- n>u2</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>();</c-> <c- o>::</c-><c- k>new</c-> <c- p>((</c-><c- b>void</c-><c- o>*</c-><c- p>)</c-><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>u2</c-><c- p>))</c-> <c- n>T</c-><c- p>(</c-><c- n>lv</c-><c- p>);</c-></code></p> </li></ul> </small>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> We intend that a type may be relocatable
regardless of whether it is copy-constructible; but, if it is copy-constructible then copy-and-destroy
must have the same semantics as move-and-destroy. We intend that a type may be relocatable regardless of
whether it is assignable; but, if it is assignable then assignment must have the same semantics as
destroy-and-copy or destroy-and-move.
The semantic requirements on assignment help us optimize <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code> and <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code>. <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>forward_list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> satisfies <code class="highlight"><c- n>relocatable</c-></code>, but it models <code class="highlight"><c- n>relocatable</c-></code> only when all relevant objects have equal allocators.</p>
   <h2 class="heading settled" data-level="5" id="alternatives"><span class="secno">5. </span><span class="content">Rationale and alternatives</span><a class="self-link" href="#alternatives"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="maybe-trivially-relocatable"><span class="secno">5.1. </span><span class="content">Attribute <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code></span><a class="self-link" href="#maybe-trivially-relocatable"></a></h3>
   <p>The Clang patch currently available on Godbolt Compiler Explorer supports both <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> and another attribute called <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>,
which John McCall requested that I explore.</p>
   <p>See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1144r4.html#maybe-trivially-relocatable">P1144R4 section 6.2</a> for discussion of the <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code> attribute, including the reasons
I do not propose it for standardization.</p>
   <p>In Issaquah (February 2023), <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> suggested a very similar design to <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>.
EWGI took a three-way straw poll on the design of <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> versus <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>,
with an inconclusive 7–5–6 vote (the author of P1144 voting "For" and the three representatives of P2786
presumably voting "Against."</p>
   <h3 class="heading settled" data-level="5.2" id="pmr-concerns"><span class="secno">5.2. </span><span class="content">Confusing interactions with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-></code></span><a class="self-link" href="#pmr-concerns"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> This section was added in P1144R5 and revised in P1144R7.
Here I assume libc++, where <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> is trivially relocatable.
Feel free to substitute your favorite trivially relocatable container type;
I’m sticking with <code class="highlight"><c- n>string</c-></code> for these examples because it is short
and easy to spell.</p>
   <p>P1144 aims to permit efficient insertion and erasure in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-></code>. <a href="https://p1144.godbolt.org/z/vv5q69q44">Example:</a></p>
<pre class="language-c++ highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>></c-> <c- n>vs</c-><c- p>(</c-><c- mi>501</c-><c- p>);</c->
<c- n>vs</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>vs</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
</pre>
   <p>This <code class="highlight"><c- n>erase</c-></code> requires us to shift down 500 <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> objects, which can be done either
by 500 calls to <code class="highlight"><c- n>string</c-><c- o>::</c-><c- k>operator</c-><c- o>=</c-></code> followed by one call to <code class="highlight"><c- o>~</c-><c- n>string</c-></code>, or by
one call to <code class="highlight"><c- o>~</c-><c- n>string</c-></code> followed by a <code class="highlight"><c- n>memmove</c-></code> (as seen for example in <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a> and BSL;
see <a href="#applications">table §2.1</a>). We want to permit BSL’s implementation.
That’s why since P1144R5, the definition of <code class="highlight"><c- k>concept</c-> <c- nc>relocatable</c-></code> in <a href="#wording-concept.relocatable">§4.4</a> places semantic requirements on <code class="highlight"><c- n>T</c-></code>'s assignment operators (if they exist) as well as on <code class="highlight"><c- n>T</c-></code>'s constructors and destructors.</p>
   <p><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>polymorphic_allocator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> is a trivially relocatable type:</p>
<pre class="language-c++ highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>polymorphic_allocator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>></c-> <c- n>va</c-><c- p>;</c->
<c- n>va</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- o>&amp;</c-><c- n>mr1</c-><c- p>);</c->
<c- n>va</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- o>&amp;</c-><c- n>mr2</c-><c- p>);</c->
<c- n>va</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- o>&amp;</c-><c- n>mr3</c-><c- p>);</c->
<c- n>va</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>va</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->  <c- c1>// A</c->
</pre>
   <p>Line "A" can use trivial relocation (<code class="highlight"><c- n>memmove</c-></code>) because it is fast and correct:
after line "A" we will have <code class="highlight"><c- n>vv</c-><c- p>[</c-><c- mi>0</c-><c- p>].</c-><c- n>resource</c-><c- p>()</c-> <c- o>==</c-> <c- o>&amp;</c-><c- n>mr2</c-></code>.
But an STL container <em>using</em> a <code class="highlight"><c- n>polymorphic_allocator</c-></code> suddenly becomes problematic:</p>
<pre class="language-c++ highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-><c- o>></c-> <c- n>vp</c-><c- p>;</c->
<c- n>vv</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- s>"1"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>mr1</c-><c- p>);</c->
<c- n>vv</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- s>"2"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>mr2</c-><c- p>);</c->
<c- n>vv</c-><c- p>.</c-><c- n>emplace_back</c-><c- p>(</c-><c- s>"3"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>mr3</c-><c- p>);</c->
<c- n>vv</c-><c- p>.</c-><c- n>reserve</c-><c- p>(</c-><c- mi>1000</c-><c- p>);</c->  <c- c1>// B</c->
<c- n>vv</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>vv</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->  <c- c1>// C</c->
</pre>
   <p>Line "B" can certainly use trivial relocation (<code class="highlight"><c- n>memcpy</c-></code>) because it is fast and correct.
But on line "C", the difference between <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>string</c-><c- o>::</c-><c- k>operator</c-><c- o>=</c-></code> and <code class="highlight"><c- n>memmove</c-></code> is detectable:
the former makes <code class="highlight"><c- n>vp</c-><c- p>[</c-><c- mi>0</c-><c- p>].</c-><c- n>get_allocator</c-><c- p>().</c-><c- n>resource</c-><c- p>()</c-> <c- o>==</c-> <c- o>&amp;</c-><c- n>mr1</c-></code> and the latter would make <code class="highlight"><c- n>vp</c-><c- p>[</c-><c- mi>0</c-><c- p>].</c-><c- n>get_allocator</c-><c- p>().</c-><c- n>resource</c-><c- p>()</c-> <c- o>==</c-> <c- o>&amp;</c-><c- n>mr2</c-></code>. Finally, hypothetically, if <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code> were
implemented in terms of a single <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> followed by a call to <code class="highlight"><c- o>~</c-><c- n>string</c-></code>, we’d have UB here
because it is UB to <code class="highlight"><c- n>swap</c-></code> strings with unequal allocators.</p>
   <p>For now, P1144R7’s proposed wording implies that <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> must not be marked as trivially relocatable.
But if we add some blanket wording setting appropriate preconditions on <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> (for example, permitting <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code> and <code class="highlight"><c- n>deque</c-><c- o>::</c-><c- n>erase</c-></code> to be implemented in terms of <code class="highlight"><c- n>rotate</c-></code>,
or forbidding STL containers from containing PMR types with unequal allocators), then
vendors could make <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> trivially relocatable.</p>
   <p class="issue" id="issue-97f1a6a8"><a class="self-link" href="#issue-97f1a6a8"></a> What new wording is needed to achieve this?</p>
   <p class="note" role="note"><span class="marker">Note:</span> Regardless, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>polymorphic_allocator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> itself is trivially relocatable.
The problem above arises from <code class="highlight"><c- n>propagate_on_move_assignment</c-></code> etc., which affect the behavior of
the <em>container’s</em> <code class="highlight"><c- k>operator</c-><c- o>=</c-></code>. The author of the container makes
the choice whether to respect POCMA/POCCA/POCS, and also makes the choice
when to warrant trivial relocatability. These choices are correlated, and so it is natural that
they should be made by the same person, at the same place in the source code.</p>
   <h3 class="heading settled" data-level="5.3" id="overlap-concerns"><span class="secno">5.3. </span><span class="content">Overlapping base-class subobjects</span><a class="self-link" href="#overlap-concerns"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> This section was added in P1144R7.</p>
   <p>In the following snippet, <code class="highlight"><c- k>struct</c-> <c- nc>Dangerous</c-></code> fails to be trivially relocatable in practice
because its assignment operator doesn’t overwrite all <code class="highlight"><c- k>sizeof</c-><c- p>(</c-><c- n>Dangerous</c-><c- p>)</c-></code> bytes of the
destination object. The tail padding of <code class="highlight"><c- n>Dangerous</c-></code> is allowed to contain the value of <code class="highlight"><c- n>Derived</c-><c- o>::</c-><c- n>k</c-></code>. (<a href="https://godbolt.org/z/T7rzrY3x9">Godbolt.</a>)</p>
<pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>Dangerous</c-> <c- p>{</c->
    <c- n>Dangerous</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>,</c-> <c- b>int</c-> <c- n>j</c-><c- p>)</c-> <c- o>:</c-> <c- n>i</c-><c- p>(</c-><c- n>i</c-><c- p>),</c-> <c- n>j</c-><c- p>(</c-><c- n>j</c-><c- p>)</c-> <c- p>{}</c->
    <c- b>int</c-> <c- n>i</c-><c- p>;</c->
    <c- b>short</c-> <c- n>j</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_standard_layout_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-><c- p>);</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-><c- p>);</c->

<c- k>struct</c-> <c- nc>Derived</c-> <c- o>:</c-> <c- n>Dangerous</c-> <c- p>{</c->
    <c- n>Derived</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>,</c-> <c- b>int</c-> <c- n>j</c-><c- p>,</c-> <c- b>int</c-> <c- n>k</c-><c- p>)</c-> <c- o>:</c-> <c- n>Dangerous</c-><c- p>(</c-><c- n>i</c-><c- p>,</c-> <c- n>j</c-><c- p>),</c-> <c- n>k</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-> <c- p>{}</c->
    <c- b>short</c-> <c- n>k</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- o>!</c-><c- n>std</c-><c- o>::</c-><c- n>is_standard_layout_v</c-><c- o>&lt;</c-><c- n>Derived</c-><c- o>></c-><c- p>);</c->
<c- k>static_assert</c-><c- p>(</c-><c- o>!</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Derived</c-><c- o>></c-><c- p>);</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>Derived</c-> <c- n>a</c-> <c- o>=</c-> <c- n>Derived</c-><c- p>(</c-><c- mi>1</c-><c- p>,</c-><c- mi>2</c-><c- p>,</c-><c- mi>3</c-><c- p>);</c->
    <c- n>Derived</c-> <c- n>b</c-> <c- o>=</c-> <c- n>Derived</c-><c- p>(</c-><c- mi>4</c-><c- p>,</c-><c- mi>5</c-><c- p>,</c-><c- mi>6</c-><c- p>);</c->
    <c- n>Dangerous</c-> <c- o>&amp;</c-><c- n>ra</c-> <c- o>=</c-> <c- n>a</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>rb</c-> <c- o>=</c-> <c- n>b</c-><c- p>;</c->
    <c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>ra</c-><c- p>,</c-> <c- n>rb</c-><c- p>);</c->
    <c- n>assert</c-><c- p>(</c-><c- n>a</c-><c- p>.</c-><c- n>k</c-> <c- o>==</c-> <c- mi>3</c-> <c- o>&amp;&amp;</c-> <c- n>b</c-><c- p>.</c-><c- n>k</c-> <c- o>==</c-> <c- mi>6</c-><c- p>);</c->
<c- p>}</c->
</pre>
   <p><a data-link-type="biblio" href="#biblio-subspace" title="Trivially Relocatable Types in C++/Subspace">[Subspace]</a> presented a version of this snippet, which led to the suggestion to consider only
standard-layout types "naturally" trivially relocatable. Unfortunately, that criterion affects only <code class="highlight"><c- n>Derived</c-></code>, whereas it’s <code class="highlight"><c- n>Dangerous</c-></code> that we can’t trivially swap.</p>
   <p>Possible solution #1 is due to <a data-link-type="biblio" href="#biblio-subspace" title="Trivially Relocatable Types in C++/Subspace">[Subspace]</a>: Bring the ABI notion of "data size" into standard C++,
so that we can say that the "data size" of <code class="highlight"><c- n>Dangerous</c-></code> is less than its "size." Types with "data size"
less than "size" aren’t naturally trivially relocatable. But this is painful, because it makes <code class="highlight"><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-></code> false.</p>
   <p>Possible solution #2: Don’t expose the ABI notion of "data size," but do take ABI into account
when deciding whether <code class="highlight"><c- n>Dangerous</c-></code> is naturally trivially relocatable. This makes <code class="highlight"><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-></code> implementation-defined in theory (false in practice) —<wbr>even though it is trivially copyable!
The difficulty here is crafting the wording.</p>
   <p>Possible solution #3: Bring the ABI notion of "data size" into standard C++, and make the trivial
version of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>T</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>)</c-></code> swap only <code class="highlight"><c- n>datasizeof</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> bytes of memory instead of <code class="highlight"><c- k>sizeof</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> bytes.
This makes it difficult for the vendor to benefit from trivial relocation in <code class="highlight"><c- n>rotate</c-></code> (because
just calling <code class="highlight"><c- n>swap</c-></code> won’t swap all the bytes, which makes it impossible for the optimizer
to coalesce adjacent memcpy operations into one big memcpy).
This makes <code class="highlight"><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-></code> true, makes <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>ra</c-><c- p>,</c-> <c- n>rb</c-><c- p>)</c-></code> trivial,
and makes <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> non-trivial.</p>
   <p>Possible solution #4: Disallow <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>T</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>)</c-></code> from using trivial relocation unless
it can prove that it’s operating on complete objects. This would also disallow e.g. <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> from using trivial relocation unless it’s operating on complete objects (e.g.
because it received a contiguous range). This creates fewer surprises, but makes it difficult
for the vendor to benefit from trivial relocation in <code class="highlight"><c- n>rotate</c-></code> (because they can’t just get
it for free by calling <code class="highlight"><c- n>swap</c-></code>; they’d have to create a second entrypoint <code class="highlight"><c- n>__swap_complete_objects</c-></code> and figure out how to call that instead of <code class="highlight"><c- n>swap</c-></code> from algorithms that would benefit from it).
This makes <code class="highlight"><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-></code> true, makes <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>ra</c-><c- p>,</c-> <c- n>rb</c-><c- p>)</c-></code> non-trivial,
and makes <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> trivial with heroics.</p>
   <p>Possible solution #5 is what <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a> implicitly assumed: Put a precondition on <code class="highlight"><c- n>swap</c-><c- p>(</c-><c- n>T</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>)</c-></code> (both the template and user-defined ADL overloads) that says it’s UB if either argument refers
to an overlapping subobject.
This makes <code class="highlight"><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Dangerous</c-><c- o>></c-></code> true, makes <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>ra</c-><c- p>,</c-> <c- n>rb</c-><c- p>)</c-></code> undefined behavior,
and makes <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> trivial.
The difficulty here is getting WG21 to accept a new precondition on <code class="highlight"><c- n>swap</c-></code>.</p>
   <h2 class="heading settled" data-level="6" id="acknowledgements"><span class="secno">6. </span><span class="content">Acknowledgements</span><a class="self-link" href="#acknowledgements"></a></h2>
   <p>Thanks to Pablo Halpern for <a data-link-type="biblio" href="#biblio-n4158" title="N4158: Destructive Move (rev 1)">[N4158]</a>, to which this paper bears a striking resemblance —<wbr>including the meaning assigned to the word "trivial," and the library-algorithm approach to avoiding the
problems with "lame duck objects" discussed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm#Alternative%20move%20designs">the final section</a> of <a data-link-type="biblio" href="#biblio-n1377" title="N1377: A Proposal to Add Move Semantics Support to the C++ Language">[N1377]</a>. See <a href="http://wiki.edg.com/bin/view/Wg21rapperswil2014/N4034">discussion of N4034 at Rapperswil</a> (June 2014)
and <a href="http://wiki.edg.com/bin/view/Wg21urbana-champaign/EvolutionWorkingGroup#N4158_Destructive_Move_Rev_1">discussion
of N4158 at Urbana</a> (November 2014).</p>
   <p>Significantly different approaches to this problem have previously appeared in Rodrigo Castro Campos’s <a data-link-type="biblio" href="#biblio-n2754" title="N2754: TriviallyDestructibleAfterMove and TriviallyReallocatable (rev 3)">[N2754]</a>, Denis Bider’s <a data-link-type="biblio" href="#biblio-p0023r0" title="P0023R0: Relocator: Efficiently Moving Objects">[P0023R0]</a> (introducing a core-language "relocation" operator), and
Niall Douglas’s <a data-link-type="biblio" href="#biblio-p1029r3" title="P1029R3: move = bitcopies">[P1029R3]</a> (treating trivial relocatability as an aspect of move-construction in isolation,
rather than an aspect of the class type as a whole). A less different approach is taken
in Mungo Gill &amp; Alisdair Meredith’s <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a>.</p>
   <p>Thanks to Elias Kosunen, Niall Douglas, John Bandela, and Nicolas Lesser for their feedback on early drafts of P1144R0.</p>
   <p>Thanks to Nicolas Lesser and John McCall for their review comments on the Clang implementation <a data-link-type="biblio" href="#biblio-d50119" title="Compiler support for P1144R0 __is_trivially_relocatable(T)">[D50119]</a>.</p>
   <p>Many thanks to Matt Godbolt for allowing me to install my Clang fork on Compiler Explorer
(<a href="https://p1144.godbolt.org/z/oWEd_X">godbolt.org</a>). See also <a data-link-type="biblio" href="#biblio-announcing" title="Announcing &quot;trivially relocatable&quot;">[Announcing]</a>.</p>
   <p>Thanks to Howard Hinnant for appearing with me on <a data-link-type="biblio" href="#biblio-cppchat" title="cpp.chat episode 40: It works but it&apos;s undefined behavior">[CppChat]</a>, and to Jon Kalb and Phil Nash for hosting us.</p>
   <p>Thanks to Marc Glisse for his work integrating a "trivially relocatable" trait into GNU libstdc++
and for answering my questions on <a href="https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87106">GCC bug 87106</a>.</p>
   <p>Thanks to Jens Maurer for his feedback on P1144R3 at Kona 2019, and to Corentin Jabot for championing
P1144R4 at Prague 2020.</p>
   <p>Thanks to Dana Jansens for her contributions re overlapping and non-standard-layout types (see <a data-link-type="biblio" href="#biblio-subspace" title="Trivially Relocatable Types in C++/Subspace">[Subspace]</a>),
to Alisdair Meredith for our extensive discussions during the February 2023 drafting of <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a>,
to Giuseppe D’Angelo and Thiago Maceira for contributing the Qt entries in <a href="#applications">table §2.1</a>,
and to Giuseppe D’Angelo for extensive review comments and discussion.</p>
   <h2 class="heading settled" id="polls"><span class="content">Appendix A: Straw polls</span><a class="self-link" href="#polls"></a></h2>
   <h3 class="heading settled" id="taken-polls-2023-02-10"><span class="content">Polls taken at EWGI at Issaquah on 2023-02-10</span><a class="self-link" href="#taken-polls-2023-02-10"></a></h3>
   <p>Arthur O’Dwyer presented P1144R6. Alisdair Meredith presented <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> (which proposed a <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>-style facility, and expressed it as a contextual keyword instead
of an attribute). EWGI took the following <a href="https://wiki.edg.com/bin/view/Wg21issaquah2023/EWGIP1144R6">straw polls</a> (as well as polls on attribute syntax and on both papers' readiness for EWG).</p>
   <table class="def">
    <tbody>
     <tr>
      <th style="width: 70%;">
      <th><strong>SF</strong>
      <th><strong>F</strong>
      <th><strong>N</strong>
      <th><strong>A</strong>
      <th><strong>SA</strong>
     <tr>
      <th><small>The problem presented in P1144/P2786 is worth solving.</small>
      <th> 10 
      <th> 8 
      <th> 0 
      <th> 0 
      <th> 0 
     <tr>
      <th><small>The problem being introduced in P1144/P2786 should be solved in a more general way instead of as proposed.</small>
      <th> 3 
      <th> 0 
      <th> 5 
      <th> 6 
      <th> 4 
     <tr>
      <th><small>The annotation should "trust the user" as in P1144R6’s <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> ("sharp knife"),
               instead of diagnosing as in P1144R6’s <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code> and P2786R0’s <code class="highlight"><c- n>trivially_relocatable</c-></code> ("dull knife"). Three-way poll.</small>
      <th> — 
      <th> 7 
      <th> 5 
      <th> 6 
      <th> — 
   </table>
   <h3 class="heading settled" id="taken-polls-2020-02-13"><span class="content">Polls taken at EWGI at Prague on 2020-02-13</span><a class="self-link" href="#taken-polls-2020-02-13"></a></h3>
   <p>Corentin Jabot championed P1144R4. EWGI discussed P1144R4 and Niall Douglas’s <a data-link-type="biblio" href="#biblio-p1029r3" title="P1029R3: move = bitcopies">[P1029R3]</a> consecutively,
then took the following <a href="https://wiki.edg.com/bin/view/Wg21prague/P1144R4SG17">straw polls</a> (as well as a poll on the attribute syntax).</p>
   <table class="def">
    <tbody>
     <tr>
      <th style="width: 70%;">
      <th><strong>SF</strong>
      <th><strong>F</strong>
      <th><strong>N</strong>
      <th><strong>A</strong>
      <th><strong>SA</strong>
     <tr>
      <th><small>We believe that P1029 and P1144 are sufficiently different that they should be advanced separately.</small>
      <th> 7 
      <th> 3 
      <th> 2 
      <th> 0 
      <th> 0 
     <tr>
      <th><small>EWGI is ok to have the spelling as an attribute with an expression argument.</small>
      <th> 3 
      <th> 5 
      <th> 1 
      <th> 1 
      <th> 0 
     <tr>
      <th><small>EWGI thinks the author should explore P1144 as a customizable type trait.</small>
      <th> 0 
      <th> 0 
      <th> 0 
      <th> 9 
      <th> 2 
     <tr>
      <th><small>Forward P1144 to EWG.</small>
      <th> 1 
      <th> 3 
      <th> 4 
      <th> 1 
      <th> 0 
   </table>
   <p>For polls taken September–November 2018, see <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a>.</p>
   <h2 class="heading settled" id="samples"><span class="content">Appendix B: Sample code</span><a class="self-link" href="#samples"></a></h2>
   <p>See <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a>'s Appendix B for reference implementations of <code class="highlight"><c- n>relocate</c-></code>, <code class="highlight"><c- n>relocate_at</c-></code>, and
P1144R6’s version of the <code class="highlight"><c- n>uninitialized_relocate</c-></code> library algorithm, plus
a conditionally trivially relocatable <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>optional</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.</p>
   <p>I have implemented the entire Standard Library using the <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> attribute; you can find the source code <a href="https://github.com/Quuxplusone/libcxx/tree/trivially-relocatable">on my GitHub</a> and explore the resulting codegen <a href="https://p1144.godbolt.org/z/t28saC">on Godbolt Compiler Explorer</a>.</p>
   <h2 class="heading settled" id="non-trivial-samples"><span class="content">Appendix C: Examples of non-trivially relocatable class types</span><a class="self-link" href="#non-trivial-samples"></a></h2>
   <h3 class="heading settled" id="non-trivial-sample-string"><span class="content">Class contains pointer to self</span><a class="self-link" href="#non-trivial-sample-string"></a></h3>
   <p>This fictional <code class="highlight"><c- n>short_string</c-></code> illustrates a mechanism that can apply
to any small-buffer-optimized class. <a href="https://github.com/llvm-mirror/libcxx/blob/4e7ffcaa/include/functional#L1719-L1734">libc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>function</c-></code></a> uses this mechanism and is thus not trivially relocatable.</p>
   <p>However, different mechanisms for small-buffer optimization exist. <a href="https://github.com/llvm-mirror/libcxx/blob/8fdc4918/include/any#L389-L394">libc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>any</c-></code></a> achieves small-buffer optimization
on a 24-byte buffer, without (necessarily) sacrificing trivial relocatability.</p>
   <p><small></small></p>
   <small> <pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>short_string</c-> <c- p>{</c->
    <c- b>char</c-> <c- o>*</c-><c- n>data_</c-> <c- o>=</c-> <c- n>buffer_</c-><c- p>;</c->
    <c- b>size_t</c-> <c- n>size_</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c->
    <c- b>char</c-> <c- n>buffer_</c-><c- p>[</c-><c- mi>8</c-><c- p>]</c-> <c- o>=</c-> <c- p>{};</c->

    <c- k>const</c-> <c- b>char</c-> <c- o>*</c-><c- nf>data</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>data_</c-><c- p>;</c-> <c- p>}</c->

    <c- n>short_string</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- n>short_string</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-> <c- o>*</c-><c- n>s</c-><c- p>)</c-> <c- o>:</c-> <c- n>size_</c-><c- p>(</c-><c- n>strlen</c-><c- p>(</c-><c- n>s</c-><c- p>))</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>size_</c-> <c- o>&lt;</c-> <c- k>sizeof</c-> <c- n>buffer_</c-><c- p>)</c->
            <c- n>strcpy</c-><c- p>(</c-><c- n>buffer_</c-><c- p>,</c-> <c- n>s</c-><c- p>);</c->
        <c- k>else</c->
            <c- n>data_</c-> <c- o>=</c-> <c- n>strdup</c-><c- p>(</c-><c- n>s</c-><c- p>);</c->
    <c- p>}</c->
    <c- n>short_string</c-><c- p>(</c-><c- n>short_string</c-><c- o>&amp;&amp;</c-> <c- n>s</c-><c- p>)</c-> <c- p>{</c->
        <c- n>memcpy</c-><c- p>(</c-><c- n>this</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>s</c-><c- p>,</c-> <c- k>sizeof</c-><c- p>(</c-><c- o>*</c-><c- n>this</c-><c- p>));</c->
        <c- k>if</c-> <c- p>(</c-><c- n>s</c-><c- p>.</c-><c- n>data_</c-> <c- o>==</c-> <c- n>s</c-><c- p>.</c-><c- n>buffer_</c-><c- p>)</c->
            <c- n>data_</c-> <c- o>=</c-> <c- n>buffer_</c-><c- p>;</c->
        <c- k>else</c->
            <c- n>s</c-><c- p>.</c-><c- n>data_</c-> <c- o>=</c-> <c- n>nullptr</c-><c- p>;</c->
    <c- p>}</c->
    <c- o>~</c-><c- n>short_string</c-><c- p>()</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>data_</c-> <c- o>!=</c-> <c- n>buffer_</c-><c- p>)</c->
            <c- n>free</c-><c- p>(</c-><c- n>data_</c-><c- p>);</c->
    <c- p>}</c->
<c- p>};</c->
</pre></small> 
   <h3 class="heading settled" id="non-trivial-sample-list"><span class="content">Allocated memory contains pointer to self</span><a class="self-link" href="#non-trivial-sample-list"></a></h3>
   <p><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-></code> needs somewhere to store its "past-the-end" node, commonly referred to
as the "sentinel node," whose <code class="highlight"><c- n>prev</c-></code> pointer points to the list’s last node.
If the sentinel node is allocated on the heap, then <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-></code> can be trivially
relocatable; but if the sentinel node is placed within the <code class="highlight"><c- n>list</c-></code> object itself
(as happens on libc++ and libstdc++), then relocating the <code class="highlight"><c- n>list</c-></code> object requires
fixing up the list’s last node’s <code class="highlight"><c- n>next</c-></code> pointer so that it points to the
new sentinel node inside the destination <code class="highlight"><c- n>list</c-></code> object. This fixup of an arbitrary
heap object cannot be simulated by <code class="highlight"><c- n>memcpy</c-></code>.</p>
   <p>Traditional implementations of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>map</c-></code> also store a "past-the-end"
node inside themselves and thus also fall into this category.</p>
   <p><small></small></p>
   <small> <pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>node</c-> <c- p>{</c->
    <c- n>node</c-> <c- o>*</c-><c- n>prev_</c-> <c- o>=</c-> <c- n>nullptr</c-><c- p>;</c->
    <c- n>node</c-> <c- o>*</c-><c- n>next_</c-> <c- o>=</c-> <c- n>nullptr</c-><c- p>;</c->
<c- p>};</c->
<c- k>struct</c-> <c- nc>list</c-> <c- p>{</c->
    <c- n>node</c-> <c- n>n_</c-><c- p>;</c->
    <c- n>iterator</c-> <c- nf>begin</c-><c- p>()</c-> <c- p>{</c-> <c- k>return</c-> <c- n>iterator</c-><c- p>(</c-><c- n>n_</c-><c- p>.</c-><c- n>next_</c-><c- p>);</c-> <c- p>}</c->
    <c- n>iterator</c-> <c- nf>end</c-><c- p>()</c-> <c- p>{</c-> <c- k>return</c-> <c- n>iterator</c-><c- p>(</c-><c- o>&amp;</c-><c- n>n_</c-><c- p>);</c-> <c- p>}</c->
    <c- n>list</c-><c- p>(</c-><c- n>list</c-><c- o>&amp;&amp;</c-> <c- n>l</c-><c- p>)</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>l</c-><c- p>.</c-><c- n>n_</c-><c- p>.</c-><c- n>next_</c-><c- p>)</c-> <c- n>l</c-><c- p>.</c-><c- n>n_</c-><c- p>.</c-><c- n>next_</c-><c- o>-></c-><c- n>prev_</c-> <c- o>=</c-> <c- o>&amp;</c-><c- n>n_</c-><c- p>;</c->  <c- c1>// fixup</c->
        <c- k>if</c-> <c- p>(</c-><c- n>l</c-><c- p>.</c-><c- n>n_</c-><c- p>.</c-><c- n>prev_</c-><c- p>)</c-> <c- n>l</c-><c- p>.</c-><c- n>n_</c-><c- p>.</c-><c- n>prev_</c-><c- o>-></c-><c- n>next_</c-> <c- o>=</c-> <c- o>&amp;</c-><c- n>n_</c-><c- p>;</c->  <c- c1>// fixup</c->
        <c- n>n_</c-> <c- o>=</c-> <c- n>l</c-><c- p>.</c-><c- n>n_</c-><c- p>;</c->
        <c- n>l</c-><c- p>.</c-><c- n>n_</c-> <c- o>=</c-> <c- n>node</c-><c- p>{};</c->
    <c- p>}</c->
    <c- c1>// ...</c->
<c- p>};</c->
</pre></small> 
   <h3 class="heading settled" id="non-trivial-sample-offset-ptr"><span class="content">Class invariant depends on <code class="highlight"><c- k>this</c-></code></span><a class="self-link" href="#non-trivial-sample-offset-ptr"></a></h3>
   <p>The <code class="highlight"><c- n>offset_ptr</c-></code> provided by <a data-link-type="biblio" href="#biblio-boostinterprocess" title="Mapping Address Independent Pointer: offset_ptr">[Boost.Interprocess]</a> is an example of this category.</p>
   <p><small></small></p>
   <small> <pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>offset_ptr</c-> <c- p>{</c->
    <c- b>uintptr_t</c-> <c- n>value_</c-><c- p>;</c->

    <c- b>uintptr_t</c-> <c- nf>here</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- b>uintptr_t</c-><c- p>(</c-><c- n>this</c-><c- p>);</c-> <c- p>}</c->
    <c- b>uintptr_t</c-> <c- nf>distance_to</c-><c- p>(</c-><c- b>void</c-> <c- o>*</c-><c- n>p</c-><c- p>)</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- b>uintptr_t</c-><c- p>(</c-><c- n>p</c-><c- p>)</c-> <c- o>-</c-> <c- n>here</c-><c- p>();</c-> <c- p>}</c->
    <c- b>void</c-> <c- o>*</c-><c- nf>get</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- p>(</c-><c- b>void</c-><c- o>*</c-><c- p>)(</c-><c- n>here</c-><c- p>()</c-> <c- o>+</c-> <c- n>value_</c-><c- p>);</c-> <c- p>}</c->

    <c- n>offset_ptr</c-><c- p>()</c-> <c- o>:</c-> <c- n>value_</c-><c- p>(</c-><c- n>distance_to</c-><c- p>(</c-><c- n>nullptr</c-><c- p>))</c-> <c- p>{}</c->
    <c- n>offset_ptr</c-><c- p>(</c-><c- b>void</c-> <c- o>*</c-><c- n>p</c-><c- p>)</c-> <c- o>:</c-> <c- n>value_</c-><c- p>(</c-><c- n>distance_to</c-><c- p>(</c-><c- n>p</c-><c- p>))</c-> <c- p>{}</c->
    <c- n>offset_ptr</c-><c- p>(</c-><c- k>const</c-> <c- n>offset_ptr</c-><c- o>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- o>:</c-> <c- n>value_</c-><c- p>(</c-><c- n>distance_to</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>get</c-><c- p>()))</c-> <c- p>{}</c->
    <c- n>offset_ptr</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>offset_ptr</c-><c- o>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- p>{</c->
        <c- n>value_</c-> <c- o>=</c-> <c- n>distance_to</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>get</c-><c- p>());</c->
        <c- k>return</c-> <c- o>*</c-><c- n>this</c-><c- p>;</c->
    <c- p>}</c->
    <c- o>~</c-><c- n>offset_ptr</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
<c- p>};</c->
</pre></small> 
   <h3 class="heading settled" id="non-trivial-sample-registry"><span class="content">Program invariant depends on <code class="highlight"><c- k>this</c-></code></span><a class="self-link" href="#non-trivial-sample-registry"></a></h3>
   <p>In the following snippet, <code class="highlight"><c- k>struct</c-> <c- nc>Widget</c-></code> is relocatable, but not
trivially relocatable, because the relocation operation of destroying a <code class="highlight"><c- n>Widget</c-></code> at point A
and constructing a new <code class="highlight"><c- n>Widget</c-></code> at point B has behavior that is observably different
from a simple <code class="highlight"><c- n>memcpy</c-></code>.</p>
   <p><small></small></p>
   <small> <pre class="language-c++ highlight"><c- n>std</c-><c- o>::</c-><c- n>set</c-><c- o>&lt;</c-><c- b>void</c-> <c- o>*></c-> <c- n>registry</c-><c- p>;</c->

<c- k>struct</c-> <c- nc>registered_object</c-> <c- p>{</c->
    <c- n>registered_object</c-><c- p>()</c-> <c- p>{</c-> <c- n>registry</c-><c- p>.</c-><c- n>insert</c-><c- p>(</c-><c- n>this</c-><c- p>);</c-> <c- p>}</c->
    <c- n>registered_object</c-><c- p>(</c-><c- n>registered_object</c-><c- o>&amp;&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- n>registered_object</c-><c- p>(</c-><c- k>const</c-> <c- n>registered_object</c-><c- o>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- n>registered_object</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>=</c-><c- p>(</c-><c- n>registered_object</c-><c- o>&amp;&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- n>registered_object</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>registered_object</c-><c- o>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- o>~</c-><c- n>registered_object</c-><c- p>()</c-> <c- p>{</c-> <c- n>registry</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>this</c-><c- p>);</c-> <c- p>}</c->
<c- p>};</c->

<c- k>struct</c-> <c- nc>Widget</c-> <c- o>:</c-> <c- n>registered_object</c-> <c- p>{};</c->
</pre></small> 
   <h3 class="heading settled" id="non-trivial-sample-polymorphic"><span class="content">Polymorphic downcast effectively relies on offset-into-self</span><a class="self-link" href="#non-trivial-sample-polymorphic"></a></h3>
   <p>Thanks to David Stone for this example.
In the following snippet, <code class="highlight"><c- k>struct</c-> <c- nc>Base</c-></code> is relocatable, but not trivially relocatable,
because its copy constructor and assignment operator do not copy the entire state of the
right-hand object. (Notice that <code class="highlight"><c- n>pf</c-></code> is initialized with <code class="highlight"><c- n>f</c-></code>, not with a copy of <code class="highlight"><c- n>o</c-><c- p>.</c-><c- n>pf</c-></code>.)</p>
<pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>Base</c-> <c- p>{</c->
    <c- k>static</c-> <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- n>Base</c-><c- o>*</c-><c- p>)</c-> <c- p>{</c-> <c- k>return</c-> <c- mi>21</c-><c- p>;</c-> <c- p>}</c->
    <c- b>int</c-> <c- p>(</c-><c- o>*</c-><c- n>pf</c-><c- p>)(</c-><c- n>Base</c-><c- o>*</c-><c- p>);</c->
    <c- n>Base</c-><c- p>(</c-><c- b>int</c-> <c- p>(</c-><c- o>*</c-><c- n>pf</c-><c- p>)(</c-><c- n>Base</c-><c- o>*</c-><c- p>)</c-> <c- o>=</c-> <c- n>f</c-><c- p>)</c-> <c- o>:</c-> <c- n>pf</c-><c- p>(</c-><c- n>pf</c-><c- p>)</c-> <c- p>{}</c->
    <c- n>Base</c-><c- p>(</c-><c- k>const</c-> <c- n>Base</c-><c- o>&amp;</c-> <c- n>o</c-><c- p>)</c-> <c- o>:</c-> <c- n>pf</c-><c- p>(</c-><c- n>f</c-><c- p>)</c-> <c- p>{}</c->
    <c- n>Base</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>Base</c-><c- o>&amp;</c-><c- p>)</c-> <c- p>{</c-> <c- k>return</c-> <c- o>*</c-><c- n>this</c-><c- p>;</c-> <c- p>}</c->
<c- p>};</c->
<c- k>struct</c-> <c- nc>Derived</c-> <c- o>:</c-> <c- n>Base</c-> <c- p>{</c->
    <c- k>static</c-> <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- n>Base</c-> <c- o>*</c-><c- n>self</c-><c- p>)</c-> <c- p>{</c-> <c- k>return</c-> <c- p>((</c-><c- n>Derived</c-><c- o>*</c-><c- p>)</c-><c- n>self</c-><c- p>)</c-><c- o>-></c-><c- n>x</c-><c- p>;</c-> <c- p>}</c->
    <c- n>Derived</c-><c- p>()</c-> <c- o>:</c-> <c- n>Base</c-><c- p>(</c-><c- n>f</c-><c- p>)</c-> <c- p>{}</c->
    <c- n>Derived</c-><c- p>(</c-><c- k>const</c-> <c- n>Derived</c-><c- o>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- n>Derived</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>Derived</c-><c- o>&amp;</c-> <c- n>o</c-><c- p>)</c-> <c- p>{</c-> <c- n>x</c-> <c- o>=</c-> <c- n>o</c-><c- p>.</c-><c- n>x</c-><c- p>;</c-> <c- k>return</c-> <c- o>*</c-><c- n>this</c-><c- p>;</c-> <c- p>}</c->
    <c- b>int</c-> <c- n>x</c-> <c- o>=</c-> <c- mi>42</c-><c- p>;</c->
<c- p>};</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>Base</c-><c- o>&amp;&amp;</c-> <c- n>d</c-> <c- o>=</c-> <c- n>Derived</c-><c- p>();</c->
    <c- n>Base</c-><c- o>&amp;&amp;</c-> <c- n>b</c-> <c- o>=</c-> <c- n>Base</c-><c- p>();</c->
    <c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>b</c-><c- p>,</c-> <c- n>d</c-><c- p>);</c->
    <c- n>printf</c-><c- p>(</c-><c- s>"%d</c-><c- se>\n</c-><c- s>"</c-><c- p>,</c-> <c- n>b</c-><c- p>.</c-><c- n>pf</c-><c- p>(</c-><c- o>&amp;</c-><c- n>b</c-><c- p>));</c->
<c- p>}</c->
</pre>
   <p>The above snippet is isomorphic to a classically polymorphic hierarchy
with virtual methods. Here is the same snippet using <code class="highlight"><c- k>virtual</c-></code>:</p>
<pre class="language-c++ highlight"><c- k>struct</c-> <c- nc>Base</c-> <c- p>{</c->
    <c- n>virtual</c-> <c- b>int</c-> <c- n>f</c-><c- p>()</c-> <c- p>{</c-> <c- k>return</c-> <c- mi>21</c-><c- p>;</c-> <c- p>}</c->
<c- p>};</c->
<c- k>struct</c-> <c- nc>Derived</c-> <c- o>:</c-> <c- n>Base</c-> <c- p>{</c->
    <c- b>int</c-> <c- nf>f</c-><c- p>()</c-> <c- n>override</c-> <c- p>{</c-> <c- k>return</c-> <c- n>x</c-><c- p>;</c-> <c- p>}</c->
    <c- b>int</c-> <c- n>x</c-> <c- o>=</c-> <c- mi>42</c-><c- p>;</c->
<c- p>};</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>Base</c-><c- o>&amp;&amp;</c-> <c- n>b</c-> <c- o>=</c-> <c- n>Base</c-><c- p>();</c->
    <c- n>Base</c-><c- o>&amp;&amp;</c-> <c- n>d</c-> <c- o>=</c-> <c- n>Derived</c-><c- p>();</c->
    <c- n>std</c-><c- o>::</c-><c- n>swap</c-><c- p>(</c-><c- n>b</c-><c- p>,</c-> <c- n>d</c-><c- p>);</c->
    <c- n>printf</c-><c- p>(</c-><c- s>"%d</c-><c- se>\n</c-><c- s>"</c-><c- p>,</c-> <c- n>b</c-><c- p>.</c-><c- n>f</c-><c- p>());</c->
<c- p>}</c->
</pre>
   <p>This is why (since P1144R5) the compiler will not consider types with
virtual methods to be "naturally" trivially relocatable.</p>
   <h2 class="heading settled" id="implementation"><span class="content">Appendix D: Implementation experience</span><a class="self-link" href="#implementation"></a></h2>
   <p>A prototype Clang/libc++ implementation is at</p>
   <ul>
    <li data-md>
     <p><a href="https://github.com/Quuxplusone/llvm-project/tree/trivially-relocatable">github.com/Quuxplusone/llvm-project/tree/trivially-relocatable</a></p>
    <li data-md>
     <p><a href="https://p1144.godbolt.org/z/oWEd_X">godbolt.org</a>, under the name "x86-64 clang (experimental P1144)"</p>
   </ul>
   <p>Side-by-side case studies of <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code>, <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>,
and <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>(</c-><c- b>bool</c-><c- p>)]]</c-></code> are given in <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a>.</p>
   <p>As of November 2018, libstdc++ performs the <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>resize</c-></code> optimization
for any type which has manually specialized <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>__is_bitwise_relocatable</c-></code>.
(See <a href="https://godbolt.org/z/f7971hEcG">this Godbolt</a>.)
Manual specialization is also the approach used by <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, and <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>.
As of 2023-02-12, the only libstdc++ library type for which <code class="highlight"><c- n>__is_bitwise_relocatable</c-></code> has
been specialized is <code class="highlight"><c- n>deque</c-></code>; see <a data-link-type="biblio" href="#biblio-deque" title="Improve relocation ... (__is_trivially_relocatable): Specialize for deque">[Deque]</a>.</p>
   <p>Clang trunk provides a compiler builtin type trait <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> (see <a data-link-type="biblio" href="#biblio-d114732" title="[clang] Mark trivial_abi types as trivially relocatable">[D114732]</a>), which is largely the same as the trait proposed in this paper. (There are slight
differences; <a href="https://p1144.godbolt.org/z/MhncMxrdj">e.g.</a>, Clang reports polymorphic types, reference types, and incomplete types
as trivially relocatable, whereas P1144 does not. I’m not aware that any of Clang’s differences were intentional.)
Clang trunk has no equivalent of the <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> attribute, so <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> is true only for
trivially copyable types and types marked with the <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivial_abi</c-><c- p>]]</c-></code> attribute. As of 2023-02-12, Clang trunk has no conception of a type which is non-trivial for purposes of calls
and yet is trivially relocatable. But Clang’s current status is compatible with P1144 (modulo the
few unintentional differences in <code class="highlight"><c- n>__is_trivially_relocatable</c-></code> mentioned above).</p>
   <h2 class="heading settled" id="open-questions"><span class="content">Appendix E: Open questions</span><a class="self-link" href="#open-questions"></a></h2>
   <p class="issue" id="issue-7a8f73c4"><a class="self-link" href="#issue-7a8f73c4"></a> P1144R6 <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>In</c-><c- p>,</c-> <c- n>In</c-><c- p>,</c-> <c- n>Fwd</c-><c- p>)</c-></code>'s spec lacks the magic either-direction-overlap-handling of <code class="highlight"><c- n>memmove</c-></code>.
Either-direction-overlap-handling is implementable only for contiguous iterators (which can be converted to pointers);
it is not implementable for arbitrary random-access iterators. Is there ever a case where someone might want to e.g. <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>rbegin</c-><c- p>(</c-><c- n>a</c-><c- p>),</c-> <c- n>rend</c-><c- p>(</c-><c- n>a</c-><c- p>),</c-> <c- n>begin</c-><c- p>(</c-><c- n>b</c-><c- p>))</c-></code>? Do we need a separate algorithm? <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a> provides both <a href="https://github.com/qt/qtbase/blob/4dbd97c/src/corelib/tools/qcontainertools_impl.h#L203-L233"><code class="highlight"><c- n>q_relocate_overlap_n</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- b>size_t</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>)</c-></code></a> with magic overlap handling, and <a href="https://github.com/qt/qtbase/blob/4dbd97c/src/corelib/tools/qcontainertools_impl.h#L71-L85"><code class="highlight"><c- n>q_uninitialized_relocate_n</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- b>size_t</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>)</c-></code></a> without. <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> proposes only <code class="highlight"><c- n>relocate</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>)</c-></code> with magic overlap handling. <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a> proposed only <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>In</c-><c- p>,</c-> <c- n>In</c-><c- p>,</c-> <c- n>Fwd</c-><c- p>)</c-></code> without.</p>
   <p class="issue" id="issue-1b225569"><a class="self-link" href="#issue-1b225569"></a> In P1144R7, types with vptrs are never naturally trivially relocatable.
Arthur claims that types with vptrs should be used only with inheritance, which means they never do value semantics
(they slice instead), which means relocating one is always a bug, just like assigning or copying one. But <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> proposes to make polymorphic types naturally trivially relocatable. Is there any use-case for relocating polymorphic
types? Is P1144 being too conservative here?</p>
   <p class="issue" id="issue-af4e1ca3"><a class="self-link" href="#issue-af4e1ca3"></a> In P1144R7, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>>::</c-><c- n>erase</c-><c- p>(</c-><c- n>pos</c-><c- p>)</c-></code> can use trivial relocation to
"close up the window" in the vector; this is also done in <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, and <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>. The difference between
closing-the-window-by-move-assignment and closing-the-window-by-memmove is detectable in a conforming C++ program.
Therefore <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> proposes that relocation should not be allowed here.
Is there any implementation experience of P2786R0’s conservative position here?
(<a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>'s <code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>vector</c-></code> follows P1144R7’s liberal position already.)</p>
   <p class="issue" id="issue-6f93047a"><a class="self-link" href="#issue-6f93047a"></a> In P1144R6, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>a</c-><c- p>,</c-> <c- n>a</c-><c- o>+</c-><c- mi>2</c-><c- p>,</c-> <c- n>a</c-><c- o>+</c-><c- mi>8</c-><c- p>)</c-></code> on an array <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>a</c-><c- p>[</c-><c- mi>10</c-><c- p>]</c-></code> can use trivial relocation to
swap the elements. The difference between swap-by-move-assignment and swap-by-trivial-relocation is not detectable
in a conforming C++ program, because swapping <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-></code>s with unequal allocators is UB. <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> conservatively proposes that relocation should not be allowed here, anyway.
Is there any usage experience in <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, or elsewhere that bears on this question?
(Arthur’s libc++ fork does relocation here, but doesn’t really count as usage experience since he’s the only one using it.)</p>
   <p class="issue" id="issue-1f8d4266"><a class="self-link" href="#issue-1f8d4266"></a> We need a solution for potentially overlapping subobjects; see <a href="#overlap-concerns">§ 5.3 Overlapping base-class subobjects</a>.</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="index"><span class="content">Index</span><a class="self-link" href="#index"></a></h2>
  <h3 class="no-num no-ref heading settled" id="index-defined-here"><span class="content">Terms defined by this specification</span><a class="self-link" href="#index-defined-here"></a></h3>
  <ul class="index">
   <li><a href="#abstract-opdef-relocation-operation">relocation operation</a><span>, in § 4.2</span>
   <li><a href="#abstract-opdef-trivially-relocatable">trivially relocatable</a><span>, in § 4.5</span>
  </ul>
  <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="normative"><span class="content">Normative References</span><a class="self-link" href="#normative"></a></h3>
  <dl>
   <dt id="biblio-n4910">[N4910]
   <dd>Thomas Köppe. <a href="https://wg21.link/n4910"><cite>Working Draft, Standard for Programming Language C++</cite></a>. 17 March 2022. URL: <a href="https://wg21.link/n4910">https://wg21.link/n4910</a>
  </dl>
  <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-announcing">[Announcing]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2018/07/18/announcing-trivially-relocatable/"><cite>Announcing "trivially relocatable"</cite></a>. July 2018. URL: <a href="https://quuxplusone.github.io/blog/2018/07/18/announcing-trivially-relocatable/">https://quuxplusone.github.io/blog/2018/07/18/announcing-trivially-relocatable/</a>
   <dt id="biblio-bench">[Bench]
   <dd>Arthur O'Dwyer. <a href="https://github.com/Quuxplusone/from-scratch/blob/095b246d/cppnow2018/benchmark-relocatable.cc"><cite>Benchmark code from "The Best Type Traits C++ Doesn't Have"</cite></a>. April 2018. URL: <a href="https://github.com/Quuxplusone/from-scratch/blob/095b246d/cppnow2018/benchmark-relocatable.cc">https://github.com/Quuxplusone/from-scratch/blob/095b246d/cppnow2018/benchmark-relocatable.cc</a>
   <dt id="biblio-boostinterprocess">[Boost.Interprocess]
   <dd>Ion Gaztañaga. <a href="https://www.boost.org/doc/libs/1_67_0/doc/html/interprocess/offset_ptr.html"><cite>Mapping Address Independent Pointer: offset_ptr</cite></a>. 2005. URL: <a href="https://www.boost.org/doc/libs/1_67_0/doc/html/interprocess/offset_ptr.html">https://www.boost.org/doc/libs/1_67_0/doc/html/interprocess/offset_ptr.html</a>
   <dt id="biblio-bsl">[BSL]
   <dd>Bloomberg. <a href="https://github.com/bloomberg/bde/blob/962f7aa/groups/bsl/bslmf/bslmf_isbitwisemoveable.h#L8-L48"><cite>bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction</cite></a>. 2013–2022. URL: <a href="https://github.com/bloomberg/bde/blob/962f7aa/groups/bsl/bslmf/bslmf_isbitwisemoveable.h#L8-L48">https://github.com/bloomberg/bde/blob/962f7aa/groups/bsl/bslmf/bslmf_isbitwisemoveable.h#L8-L48</a>
   <dt id="biblio-cppchat">[CppChat]
   <dd>Howard Hinnant; Arthur O'Dwyer. <a href="https://www.youtube.com/watch?v=8u5Qi4FgTP8"><cite>cpp.chat episode 40: It works but it's undefined behavior</cite></a>. August 2018. URL: <a href="https://www.youtube.com/watch?v=8u5Qi4FgTP8">https://www.youtube.com/watch?v=8u5Qi4FgTP8</a>
   <dt id="biblio-d114732">[D114732]
   <dd>Devin Jeanpierre. <a href="https://reviews.llvm.org/D114732"><cite>[clang] Mark trivial_abi types as trivially relocatable</cite></a>. November 2021. URL: <a href="https://reviews.llvm.org/D114732">https://reviews.llvm.org/D114732</a>
   <dt id="biblio-d50119">[D50119]
   <dd>Arthur O'Dwyer; Nicolas Lesser; John McCall. <a href="https://reviews.llvm.org/D50119"><cite>Compiler support for P1144R0 __is_trivially_relocatable(T)</cite></a>. July 2018. URL: <a href="https://reviews.llvm.org/D50119">https://reviews.llvm.org/D50119</a>
   <dt id="biblio-deque">[Deque]
   <dd>Marc Glisse. <a href="https://github.com/gcc-mirror/gcc/commit/a9b9381580de611126c9888c1a6c12a77d9b682e"><cite>Improve relocation ... (__is_trivially_relocatable): Specialize for deque</cite></a>. November 2018. URL: <a href="https://github.com/gcc-mirror/gcc/commit/a9b9381580de611126c9888c1a6c12a77d9b682e">https://github.com/gcc-mirror/gcc/commit/a9b9381580de611126c9888c1a6c12a77d9b682e</a>
   <dt id="biblio-fixedcapacityvector">[FixedCapacityVector]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2019/02/22/p1144-fixed-capacity-vector/"><cite>P1144 case study: Moving a `fixed_capacity_vector`</cite></a>. URL: <a href="https://quuxplusone.github.io/blog/2019/02/22/p1144-fixed-capacity-vector/">https://quuxplusone.github.io/blog/2019/02/22/p1144-fixed-capacity-vector/</a>
   <dt id="biblio-folly">[Folly]
   <dd>Facebook. <a href="https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md#object-relocation"><cite>Folly documentation on "Object Relocation"</cite></a>. URL: <a href="https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md#object-relocation">https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md#object-relocation</a>
   <dt id="biblio-follyissue889">[FollyIssue889]
   <dd>Arthur O'Dwyer. <a href="https://github.com/facebook/folly/issues/889"><cite>Traits.h marks std::list as trivially relocatable, but in fact it is not</cite></a>. URL: <a href="https://github.com/facebook/folly/issues/889">https://github.com/facebook/folly/issues/889</a>
   <dt id="biblio-n1377">[N1377]
   <dd>Howard Hinnant; Peter Dimov; Dave Abrahams. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm"><cite>N1377: A Proposal to Add Move Semantics Support to the C++ Language</cite></a>. September 2002. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm</a>
   <dt id="biblio-n2271">[N2271]
   <dd>Paul Pedriana. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html#type_traits_extensions"><cite>N2271: EASTL — Electronic Arts Standard Template Library</cite></a>. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html#type_traits_extensions">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html#type_traits_extensions</a>
   <dt id="biblio-n2754">[N2754]
   <dd>Rodrigo Castro Campos. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2754.html"><cite>N2754: TriviallyDestructibleAfterMove and TriviallyReallocatable (rev 3)</cite></a>. September 2008. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2754.html">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2754.html</a>
   <dt id="biblio-n4158">[N4158]
   <dd>Pablo Halpern. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4158.pdf"><cite>N4158: Destructive Move (rev 1)</cite></a>. October 2014. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4158.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4158.pdf</a>
   <dt id="biblio-p0023r0">[P0023R0]
   <dd>Denis Bider. <a href="http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf"><cite>P0023R0: Relocator: Efficiently Moving Objects</cite></a>. April 2016. URL: <a href="http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf">http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf</a>
   <dt id="biblio-p0843r5">[P0843R5]
   <dd>Gonzalo Brito Gadeschi. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html"><cite>static_vector</cite></a>. July 2022. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html</a>
   <dt id="biblio-p1029r3">[P1029R3]
   <dd>Niall Douglas. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1029r3.pdf"><cite>P1029R3: move = bitcopies</cite></a>. January 2020. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1029r3.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1029r3.pdf</a>
   <dt id="biblio-p1144r6">[P1144R6]
   <dd>Arthur O'Dwyer. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1144r6.html"><cite>P1144R6: Object relocation in terms of move plus destroy</cite></a>. June 2022. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1144r6.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1144r6.html</a>
   <dt id="biblio-p2786r0">[P2786R0]
   <dd>Mungo Gill; Alisdair Meredith. <a href="https://wg21.link/p2786r0"><cite>P2786R0: Trivial relocatability options</cite></a>. February 2023. URL: <a href="https://wg21.link/p2786r0">https://wg21.link/p2786r0</a>
   <dt id="biblio-qt">[Qt]
   <dd><a href="https://github.com/qt/qtbase/"><cite>Qt Base</cite></a>. February 2023. URL: <a href="https://github.com/qt/qtbase/">https://github.com/qt/qtbase/</a>
   <dt id="biblio-stdrelocateiscute">[StdRelocateIsCute]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2022/05/18/std-relocate/"><cite>std::relocate's implementation is cute</cite></a>. May 2022. URL: <a href="https://quuxplusone.github.io/blog/2022/05/18/std-relocate/">https://quuxplusone.github.io/blog/2022/05/18/std-relocate/</a>
   <dt id="biblio-subobjects">[Subobjects]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2018/07/13/trivially-copyable-corner-cases/"><cite>When is a trivially copyable object not trivially copyable?</cite></a>. July 2018. URL: <a href="https://quuxplusone.github.io/blog/2018/07/13/trivially-copyable-corner-cases/">https://quuxplusone.github.io/blog/2018/07/13/trivially-copyable-corner-cases/</a>
   <dt id="biblio-subspace">[Subspace]
   <dd>Dana Jansens. <a href="https://danakj.github.io/2023/01/15/trivially-relocatable.html"><cite>Trivially Relocatable Types in C++/Subspace</cite></a>. January 2023. URL: <a href="https://danakj.github.io/2023/01/15/trivially-relocatable.html">https://danakj.github.io/2023/01/15/trivially-relocatable.html</a>
  </dl>
  <h2 class="no-num no-ref heading settled" id="issues-index"><span class="content">Issues Index</span><a class="self-link" href="#issues-index"></a></h2>
  <div style="counter-reset:issue">
   <div class="issue"> "If a type <code class="highlight"><c- n>T</c-></code> is declared with the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute, and <code class="highlight"><c- n>T</c-></code> is either not move-constructible
or not destructible, the program is ill-formed." We might want to replace this wording with
a mere "Note" <em>encouraging</em> implementations to diagnose.
See <a href="https://p1144.godbolt.org/z/ociAVX">this example</a> where a diagnostic might be unwanted. <a class="issue-return" href="#issue-20b76dab" title="Jump to section">↵</a></div>
   <div class="issue"> What new wording is needed to achieve this? <a class="issue-return" href="#issue-97f1a6a8" title="Jump to section">↵</a></div>
   <div class="issue"> P1144R6 <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>In</c-><c- p>,</c-> <c- n>In</c-><c- p>,</c-> <c- n>Fwd</c-><c- p>)</c-></code>'s spec lacks the magic either-direction-overlap-handling of <code class="highlight"><c- n>memmove</c-></code>.
Either-direction-overlap-handling is implementable only for contiguous iterators (which can be converted to pointers);
it is not implementable for arbitrary random-access iterators. Is there ever a case where someone might want to e.g. <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>rbegin</c-><c- p>(</c-><c- n>a</c-><c- p>),</c-> <c- n>rend</c-><c- p>(</c-><c- n>a</c-><c- p>),</c-> <c- n>begin</c-><c- p>(</c-><c- n>b</c-><c- p>))</c-></code>? Do we need a separate algorithm? <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a> provides both <a href="https://github.com/qt/qtbase/blob/4dbd97c/src/corelib/tools/qcontainertools_impl.h#L203-L233"><code class="highlight"><c- n>q_relocate_overlap_n</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- b>size_t</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>)</c-></code></a> with magic overlap handling, and <a href="https://github.com/qt/qtbase/blob/4dbd97c/src/corelib/tools/qcontainertools_impl.h#L71-L85"><code class="highlight"><c- n>q_uninitialized_relocate_n</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- b>size_t</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>)</c-></code></a> without. <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> proposes only <code class="highlight"><c- n>relocate</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-><c- p>)</c-></code> with magic overlap handling. <a data-link-type="biblio" href="#biblio-p1144r6" title="P1144R6: Object relocation in terms of move plus destroy">[P1144R6]</a> proposed only <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>In</c-><c- p>,</c-> <c- n>In</c-><c- p>,</c-> <c- n>Fwd</c-><c- p>)</c-></code> without. <a class="issue-return" href="#issue-7a8f73c4" title="Jump to section">↵</a></div>
   <div class="issue"> In P1144R7, types with vptrs are never naturally trivially relocatable.
Arthur claims that types with vptrs should be used only with inheritance, which means they never do value semantics
(they slice instead), which means relocating one is always a bug, just like assigning or copying one. But <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> proposes to make polymorphic types naturally trivially relocatable. Is there any use-case for relocating polymorphic
types? Is P1144 being too conservative here? <a class="issue-return" href="#issue-1b225569" title="Jump to section">↵</a></div>
   <div class="issue"> In P1144R7, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>>::</c-><c- n>erase</c-><c- p>(</c-><c- n>pos</c-><c- p>)</c-></code> can use trivial relocation to
"close up the window" in the vector; this is also done in <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, and <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>. The difference between
closing-the-window-by-move-assignment and closing-the-window-by-memmove is detectable in a conforming C++ program.
Therefore <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> proposes that relocation should not be allowed here.
Is there any implementation experience of P2786R0’s conservative position here?
(<a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>'s <code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>vector</c-></code> follows P1144R7’s liberal position already.) <a class="issue-return" href="#issue-af4e1ca3" title="Jump to section">↵</a></div>
   <div class="issue"> In P1144R6, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>a</c-><c- p>,</c-> <c- n>a</c-><c- o>+</c-><c- mi>2</c-><c- p>,</c-> <c- n>a</c-><c- o>+</c-><c- mi>8</c-><c- p>)</c-></code> on an array <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>a</c-><c- p>[</c-><c- mi>10</c-><c- p>]</c-></code> can use trivial relocation to
swap the elements. The difference between swap-by-move-assignment and swap-by-trivial-relocation is not detectable
in a conforming C++ program, because swapping <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-></code>s with unequal allocators is UB. <a data-link-type="biblio" href="#biblio-p2786r0" title="P2786R0: Trivial relocatability options">[P2786R0]</a> conservatively proposes that relocation should not be allowed here, anyway.
Is there any usage experience in <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, or elsewhere that bears on this question?
(Arthur’s libc++ fork does relocation here, but doesn’t really count as usage experience since he’s the only one using it.) <a class="issue-return" href="#issue-6f93047a" title="Jump to section">↵</a></div>
   <div class="issue"> We need a solution for potentially overlapping subobjects; see <a href="#overlap-concerns">§ 5.3 Overlapping base-class subobjects</a>. <a class="issue-return" href="#issue-1f8d4266" title="Jump to section">↵</a></div>
  </div>
  <aside aria-labelledby="infopaneltitle-for-abstract-opdef-relocation-operation" class="dfn-panel" data-for="abstract-opdef-relocation-operation" id="infopanel-for-abstract-opdef-relocation-operation">
   <span id="infopaneltitle-for-abstract-opdef-relocation-operation" style="display:none">Info about the 'relocation operation' definition.</span><b><a href="#abstract-opdef-relocation-operation">#abstract-opdef-relocation-operation</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-abstract-opdef-relocation-operation">4.5. Trivially relocatable type [basic.types.general]</a>
   </ul>
  </aside>
  <aside aria-labelledby="infopaneltitle-for-abstract-opdef-trivially-relocatable" class="dfn-panel" data-for="abstract-opdef-trivially-relocatable" id="infopanel-for-abstract-opdef-trivially-relocatable">
   <span id="infopaneltitle-for-abstract-opdef-trivially-relocatable" style="display:none">Info about the 'trivially relocatable' definition.</span><b><a href="#abstract-opdef-trivially-relocatable">#abstract-opdef-trivially-relocatable</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-abstract-opdef-trivially-relocatable">2. Introduction and motivation</a>
    <li><a href="#ref-for-abstract-opdef-trivially-relocatable①">4.7. Type traits is_relocatable etc. [meta.unary.prop]</a>
   </ul>
  </aside>
<script>/* script-dfn-panel */
"use strict";
{
    function queryAll(sel) {
        return [].slice.call(document.querySelectorAll(sel));
    }

    // Add popup behavior to all dfns to show the corresponding dfn-panel.
    var dfns = document.querySelectorAll('.dfn-paneled');
    for (let dfn of dfns) { insertDfnPopupAction(dfn); }

    document.body.addEventListener("click", (e) => {
        // If not handled already, just hide all dfn panels.
        hideAllDfnPanels();
    });

    function hideAllDfnPanels() {
        // Turn off any currently "on" or "activated" panels.
        queryAll(".dfn-panel.on, .dfn-panel.activated").forEach(el=>hideDfnPanel(el));
    }

    function showDfnPanel(dfnPanel, dfn) {
        hideAllDfnPanels(); // Only display one at this time.
        dfn.setAttribute("aria-expanded", "true");
        dfnPanel.classList.add("on");
        dfnPanel.style.left = "5px";
        dfnPanel.style.top = "0px";
        const panelRect = dfnPanel.getBoundingClientRect();
        const panelWidth = panelRect.right - panelRect.left;
        if (panelRect.right > document.body.scrollWidth) {
            // Panel's overflowing the screen.
            // Just drop it below the dfn and flip it rightward instead.
            // This still wont' fix things if the screen is *really* wide,
            // but fixing that's a lot harder without 'anchor()'.
            dfnPanel.style.top = "1.5em";
            dfnPanel.style.left = "auto";
            dfnPanel.style.right = "0px";
        }
    }

    function pinDfnPanel(dfnPanel) {
        // Switch it to "activated" state, which pins it.
        dfnPanel.classList.add("activated");
        dfnPanel.style.left = null;
        dfnPanel.style.top = null;
    }

    function hideDfnPanel(dfnPanel, dfn) {
        if(!dfn) {
            dfn = document.getElementById(dfnPanel.getAttribute("data-for"));
        }
        dfn.setAttribute("aria-expanded", "false")
        dfnPanel.classList.remove("on");
        dfnPanel.classList.remove("activated");
    }

    function toggleDfnPanel(dfnPanel, dfn) {
        if(dfnPanel.classList.contains("on")) {
            hideDfnPanel(dfnPanel, dfn);
        } else {
            showDfnPanel(dfnPanel, dfn);
        }
    }

    function insertDfnPopupAction(dfn) {
        // Find dfn panel
        const dfnPanel = document.querySelector(`.dfn-panel[data-for='${dfn.id}']`);
        if (dfnPanel) {
            const panelWrapper = document.createElement('span');
            panelWrapper.appendChild(dfnPanel);
            panelWrapper.style.position = "relative";
            panelWrapper.style.height = "0px";
            dfn.insertAdjacentElement("afterend", panelWrapper);
            dfn.setAttribute('role', 'button');
            dfn.setAttribute('aria-expanded', 'false')
            dfn.tabIndex = 0;
            dfn.classList.add('has-dfn-panel');
            dfn.addEventListener('click', (event) => {
                showDfnPanel(dfnPanel, dfn);
                event.stopPropagation();
            });
            dfn.addEventListener('keypress', (event) => {
                const kc = event.keyCode;
                // 32->Space, 13->Enter
                if(kc == 32 || kc == 13) {
                    toggleDfnPanel(dfnPanel, dfn);
                    event.stopPropagation();
                    event.preventDefault();
                }
            });

            dfnPanel.addEventListener('click', (event) => {
                pinDfnPanel(dfnPanel);
                event.stopPropagation();
            });

            dfnPanel.addEventListener('keydown', (event) => {
                if(event.keyCode == 27) { // Escape key
                    hideDfnPanel(dfnPanel, dfn);
                    event.stopPropagation();
                    event.preventDefault();
                }
            })

        } else {
            console.log("Couldn't find .dfn-panel[data-for='" + dfn.id + "']");
        }
    }
}
</script>