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

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

	body {
		counter-reset: example figure issue;

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	p {
		margin: 1em 0;
	}

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

  /* Do something nice. */

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

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

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

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

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

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

	img {
		border-style: none;
	}

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

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

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

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

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

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

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

	blockquote {
		border-color: silver;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/*
Alternate table alignment rules

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

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

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

Possible extra rowspan handling

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

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

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


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

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

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

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

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

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

		.toc li {
			clear: both;
		}

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

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

	@supports (display:grid) 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 {
			background: rgba(75%, 75%, 75%, .25);
			border-bottom: 3px solid #054572;
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


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

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

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

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

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

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

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

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

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

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

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



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

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

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

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			 * http://lea.verou.me/2012/04/background-attachment-local/
			 *
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
			            top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
			            top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }

    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 b76a1f3caa65320a39ee72dbf2680ea887ace619" name="generator">
  <link href="http://wg21.link/P1705" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>/* style-md-lists */

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

            #hidedel:checked ~ del, #hidedel:checked ~ * del { display:none; }
            #hidedel ~ #hidedel-label::before, #hidedel ~ * #hidedel-label::before { content: "☐ "; }
            #hidedel:checked ~ #hidedel-label::before, #hidedel:checked ~ * #hidedel-label::before { content: "☑ "; }
        </style>
<style>/* style-selflinks */

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

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

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

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

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

[data-link-type=biblio] {
    white-space: pre;
}</style>
<style>/* style-syntax-highlighting */

.highlight:not(.idl) { background: hsl(24, 20%, 95%); }
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</style>
 <body class="h-entry">
  <input id="hidedel" style="display:none" type="checkbox">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1705R1<br>Enumerating Core Undefined Behavior</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Draft Proposal, <time class="dt-updated" datetime="2019-09-28">2019-09-28</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="http://wg21.link/P1705">http://wg21.link/P1705</a>
     <dt>Author:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:syaghmour@apple.com">Shafik Yaghmour</a> (<span class="p-org org">Apple</span>)
     <dt>Audience:
     <dd>SG12
     <dt>Toggle Diffs:
     <dd>
      <label for="hidedel" id="hidedel-label">Hide deleted text</label>
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>Adding an undefined behavior annex to the Standard and creating an C++ undefined behavior TR</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="#intro"><span class="secno">1</span> <span class="content">Introduction</span></a>
    <li>
     <a href="#edit"><span class="secno">2</span> <span class="content">Edit History</span></a>
     <ol class="toc">
      <li><a href="#r0r1"><span class="secno">2.1</span> <span class="content">r0 → r1</span></a>
     </ol>
    <li><a href="#goalsOfAnnex"><span class="secno">3</span> <span class="content">Goals of Undefined Behavior Annex</span></a>
    <li><a href="#benefitsOfAnnex"><span class="secno">4</span> <span class="content">Benefits of Undefined Behavior Annex</span></a>
    <li><a href="#implOfAnnex"><span class="secno">5</span> <span class="content">Implementation of Undefined Behavior Annex</span></a>
    <li><a href="#stable-names"><span class="secno">6</span> <span class="content">Stable Names</span></a>
    <li><a href="#goalsOfTR"><span class="secno">7</span> <span class="content">Goals of Undefined Behavior TR</span></a>
    <li><a href="#benefitsOfTR"><span class="secno">8</span> <span class="content">Benefits of Undefined Behavior TR</span></a>
    <li><a href="#TRandCoreGuide"><span class="secno">9</span> <span class="content">How would the Undefined Behavior TR relate to the Core Guidelines</span></a>
    <li><a href="#stdLibraryUB"><span class="secno">10</span> <span class="content">What about Standard Library Undefined Behavior?</span></a>
    <li>
     <a href="#trlook"><span class="secno">11</span> <span class="content">How Might the TR look</span></a>
     <ol class="toc">
      <li>
       <a href="#lex"><span class="secno">11.1</span> <span class="content">[lex]</span></a>
       <ol class="toc">
        <li><a href="#lexphases"><span class="secno">11.1.1</span> <span class="content">[lex.phases]</span></a>
        <li><a href="#lexstring"><span class="secno">11.1.2</span> <span class="content">[lex.string]</span></a>
       </ol>
      <li>
       <a href="#basic"><span class="secno">11.2</span> <span class="content">[basic]</span></a>
       <ol class="toc">
        <li><a href="#basicdefodr"><span class="secno">11.2.1</span> <span class="content">[basic.def.odr]</span></a>
        <li><a href="#basiclife"><span class="secno">11.2.2</span> <span class="content">[basic.life]</span></a>
        <li><a href="#basicindet"><span class="secno">11.2.3</span> <span class="content">[basic.indet]</span></a>
        <li><a href="#basicstart"><span class="secno">11.2.4</span> <span class="content">[basic.start]</span></a>
       </ol>
      <li>
       <a href="#expr"><span class="secno">11.3</span> <span class="content">[expr]</span></a>
       <ol class="toc">
        <li><a href="#exprpre"><span class="secno">11.3.1</span> <span class="content">[expr.pre]</span></a>
        <li><a href="#convdouble"><span class="secno">11.3.2</span> <span class="content">[conv.double]</span></a>
        <li><a href="#convfpint"><span class="secno">11.3.3</span> <span class="content">[conv.fpint]</span></a>
        <li><a href="#exprcall"><span class="secno">11.3.4</span> <span class="content">[expr.call]</span></a>
        <li><a href="#exprstaticcast"><span class="secno">11.3.5</span> <span class="content">[expr.static.cast]</span></a>
        <li><a href="#exprdelete"><span class="secno">11.3.6</span> <span class="content">[expr.delete]</span></a>
        <li><a href="#exprmptroper"><span class="secno">11.3.7</span> <span class="content">[expr.mptr.oper]</span></a>
        <li><a href="#exprmul"><span class="secno">11.3.8</span> <span class="content">[expr.mul]</span></a>
        <li><a href="#expradd"><span class="secno">11.3.9</span> <span class="content">[expr.add]</span></a>
        <li><a href="#exprshift"><span class="secno">11.3.10</span> <span class="content">[expr.shift]</span></a>
        <li><a href="#exprass"><span class="secno">11.3.11</span> <span class="content">[expr.ass]</span></a>
       </ol>
      <li>
       <a href="#stmtstmt"><span class="secno">11.4</span> <span class="content">[stmt.stmt]</span></a>
       <ol class="toc">
        <li><a href="#stmtreturn"><span class="secno">11.4.1</span> <span class="content">[stmt.return]</span></a>
        <li><a href="#stmtdcl"><span class="secno">11.4.2</span> <span class="content">[stmt.dcl]</span></a>
       </ol>
      <li>
       <a href="#dcldcl"><span class="secno">11.5</span> <span class="content">[dcl.dcl]</span></a>
       <ol class="toc">
        <li><a href="#dcltypecv"><span class="secno">11.5.1</span> <span class="content">[dcl.type.cv]</span></a>
        <li><a href="#dclattrcontractsyn"><span class="secno">11.5.2</span> <span class="content">[dcl.attr.contract.syn]</span></a>
        <li><a href="#dclattrcontractsyn①"><span class="secno">11.5.3</span> <span class="content">[dcl.attr.contract.syn]</span></a>
        <li><a href="#dclattrcontractcheck"><span class="secno">11.5.4</span> <span class="content">[dcl.attr.contract.check]</span></a>
        <li><a href="#dclattrnoreturn"><span class="secno">11.5.5</span> <span class="content">[dcl.attr.noreturn]</span></a>
       </ol>
      <li>
       <a href="#class"><span class="secno">11.6</span> <span class="content">[class]</span></a>
       <ol class="toc">
        <li><a href="#classmfctnon-static"><span class="secno">11.6.1</span> <span class="content">[class.mfct.non-static]</span></a>
        <li><a href="#classdtor"><span class="secno">11.6.2</span> <span class="content">[class.dtor]</span></a>
        <li><a href="#classunion"><span class="secno">11.6.3</span> <span class="content">[class.union]</span></a>
        <li><a href="#classabstract"><span class="secno">11.6.4</span> <span class="content">[class.abstract]</span></a>
        <li><a href="#classbaseinit"><span class="secno">11.6.5</span> <span class="content">[class.base.init]</span></a>
        <li><a href="#classcdtor"><span class="secno">11.6.6</span> <span class="content">[class.cdtor]</span></a>
       </ol>
     </ol>
    <li><a href="#acknowledgement"><span class="secno">12</span> <span class="content">Acknowledgement</span></a>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="intro"><span class="secno">1. </span><span class="content">Introduction</span><a class="self-link" href="#intro"></a></h2>
   <p>Explaining undefined behavior is complicated. First you need to explain what undefined behavior is. Then all the
unintuitive consequences that it entails. Including removal of safety checks, turning finite loops infinite,
booleans that can both be false and true and how undefined behavior can time travel 🤯</p>
   <p>Then comes the next logical question, how can I know what all the undefined behavior are so I can avoid them.
This may be followed by an awkward silence, “That is complicated”, one might say. We might follow up and mention
we have both explicit and implicit undefined behavior. A fair response might be, 
“Makes sense but surely you can tell me what all the explicit undefined behaviors are?”. 
This would be followed by more awkward silence. Followed by a perhaps sheepish, “Well you see that is also complicated”.</p>
   <p>We would have to follow-up and point out that the C++ Standard does indeed list all the explicit undefined behavior but
you would have to manually go through the 1700+ page Standard to find them. Merely finding all the mentions of “undefined”
is only partially helpful. The Standard being a specification and not a tutorial does not explain each in plain language
and honestly some defy explanation in plain language. Examples are not always provided, neither do we have rationales or
explanations on how to avoid or catch violations of these rules (if possible).</p>
   <p>The goal of this paper is two fold. One is to create an annex of undefined behavior. The purpose would be to have a list of all the explicit
core undefined behavior along with at least one example demonstrating it. Having this list will enable the C++ community to
better grasp the scope and depth of undefined behavior. It should benefit not just users but also those teaching C++ and 
those developing tools for writing better code. It will benefit implementors because it lets them know what’s undefined
and how. It will help the committee track its undefined behavior and revisit it.</p>
   <p>The second goal would be to develop of a core undefined behavior TR, which would expand upon the content of the annex with more
examples including examples showing surprising consequences. It would also include tools if any that could aid in detecting or
avoiding each undefined behavior. If possible we would also like to include a rationale for each undefined behavior. This will
have all the benefits of that annex but with more details and rationale should aid in teaching. Additionally this should also
be a help to researchers both in understanding, developing better tools and perhaps finding alternatives approaches to
undefined behavior.</p>
   <h2 class="heading settled" data-level="2" id="edit"><span class="secno">2. </span><span class="content">Edit History</span><a class="self-link" href="#edit"></a></h2>
   <h3 class="heading settled" data-level="2.1" id="r0r1"><span class="secno">2.1. </span><span class="content">r0 → r1</span><a class="self-link" href="#r0r1"></a></h3>
   <p><a data-link-type="biblio" href="#biblio-p1705r0">[P1705R0]</a> was seen by SG12 in Cologne. This update does the
following:</p>
   <ul>
    <li data-md>
     <p>Update the implementation of undefined behavior annex section</p>
    <li data-md>
     <p>Add details on how implicit undefined behavior will be handled in the annex</p>
    <li data-md>
     <p>Add details on stable names for each undefined behavior entry</p>
    <li data-md>
     <p>Add an example of how the annex will be formatted</p>
   </ul>
   <table>
    <thead>
     <tr>
      <th>Poll
      <th>Group
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
      <th>Outcome
    <tbody>
     <tr>
      <th>Add an informative annex to the WD which lists core language UB organized by type to be maintained by someone after initial version from author.
      <th>SG12
      <th>8
      <th>2
      <th>0
      <th>0
      <th>0
      <th>✅
     <tr>
      <th>Include implicit (by omission) UB on a best effort basis.
      <th>SG12
      <th>5
      <th>4
      <th>1
      <th>0
      <th>0
      <th>✅
     <tr>
      <th>Target an informative document (TR/SD/?) that contains UB along with rationale and additional information to be maintained by SG12 after initial version from author along the lines of the contents of P1705R0
      <th>SG12
      <th>3
      <th>3
      <th>3
      <th>1
      <th>0
      <th>✅
   </table>
   <h2 class="heading settled" data-level="3" id="goalsOfAnnex"><span class="secno">3. </span><span class="content">Goals of Undefined Behavior Annex</span><a class="self-link" href="#goalsOfAnnex"></a></h2>
   <ul>
    <li data-md>
     <p>List all the explicit undefined behavior in the core language.</p>
    <li data-md>
     <p>List implicit undefined behavior in the core language on a best effort basis.</p>
    <li data-md>
     <p>Provide at least one example for each undefined behavior.</p>
   </ul>
   <h2 class="heading settled" data-level="4" id="benefitsOfAnnex"><span class="secno">4. </span><span class="content">Benefits of Undefined Behavior Annex</span><a class="self-link" href="#benefitsOfAnnex"></a></h2>
   <ul>
    <li data-md>
     <p>A definitive list of all explict core language undefined behavior.</p>
    <li data-md>
     <p>Ability to track the velocity of undefined behavior in the Standard. Is it increasing/decreasing and at what rate.</p>
    <li data-md>
     <p>Allow of better analysis:</p>
    <li data-md>
     <p>Are there classes of undefined behavior we can get better at detecting?</p>
    <li data-md>
     <p>Are there classes of UB that are canididates to convert to something else such as ill-formed or
implementation defined behavior.</p>
    <li data-md>
     <p>Provide clarity with examples.</p>
   </ul>
   <h2 class="heading settled" data-level="5" id="implOfAnnex"><span class="secno">5. </span><span class="content">Implementation of Undefined Behavior Annex</span><a class="self-link" href="#implOfAnnex"></a></h2>
   <p>Annex E will be modeled similar Annex C  with a description of each undefined behavior and at least one example. Each Annex E
entry will have its own stable name that we can use to refer to the specific undefined behavior unambiguously.</p>
   <p>There will be two LaTeX macros: one to link each annex entry back to the normative wording via a reference, and a second macro
to link the normative wording to the Annex E via a reference. Having a two way reference will us to maintain the Annex E
more seamlessly without having to worry about the normative text moving or being removed without this being reflected in 
Annex E.</p>
   <h2 class="heading settled" data-level="6" id="stable-names"><span class="secno">6. </span><span class="content">Stable Names</span><a class="self-link" href="#stable-names"></a></h2>
   <p>Stables names will take the form of ub.SectionName.UniqueName. For example:</p>
   <ul>
    <li data-md>
     <p>[ub.lex.phases.spliceucn]</p>
    <li data-md>
     <p>[ub.lex.phases.tokenconcatucn]</p>
    <li data-md>
     <p>[ub.lex.string.modstringliteral]</p>
    <li data-md>
     <p>[ub.basic.def.odr]</p>
   </ul>
   <h2 class="heading settled" data-level="7" id="goalsOfTR"><span class="secno">7. </span><span class="content">Goals of Undefined Behavior TR</span><a class="self-link" href="#goalsOfTR"></a></h2>
   <ul>
    <li data-md>
     <p>It is easier to adapt the Standard because we understand the decisions that were made and can revist them.</p>
    <li data-md>
     <p>Provide examples that demonstrate surprising consequences.</p>
    <li data-md>
     <p>Provide a rationale for each undefined behavior.</p>
    <li data-md>
     <p>Provide ways to prevent the undefined behavior.</p>
    <li data-md>
     <p>Provide ways to detect the undefined behavior.</p>
    <li data-md>
     <p>Provide live example on Compiler Explorer or other live tools that demonstrate the undefined behavior. If it can demonstrate ways to detect the undefined behavior then also include that.</p>
   </ul>
   <h2 class="heading settled" data-level="8" id="benefitsOfTR"><span class="secno">8. </span><span class="content">Benefits of Undefined Behavior TR</span><a class="self-link" href="#benefitsOfTR"></a></h2>
   <ul>
    <li data-md>
     <p>Ease teaching by providing a comprehensive reference.</p>
    <li data-md>
     <p>Ease tool development.</p>
    <li data-md>
     <p>Ease research into undefined behavior.</p>
   </ul>
   <h2 class="heading settled" data-level="9" id="TRandCoreGuide"><span class="secno">9. </span><span class="content">How would the Undefined Behavior TR relate to the Core Guidelines</span><a class="self-link" href="#TRandCoreGuide"></a></h2>
   <p>The C++ Core Guidelines are focused on "relatively high-level issues", which is appropriate for a document that seeks to
"help people to use modern C++ effectively". Undefined behavior itself may be one high-level topic and does deserve specific
mention in the Core Guidelines. The Undefined Behavior TR would be more focused, drilling into each specific core undefined
behavior with details. The undefined behavior TR would therefore inform the Core Guidelines.</p>
   <h2 class="heading settled" data-level="10" id="stdLibraryUB"><span class="secno">10. </span><span class="content">What about Standard Library Undefined Behavior?</span><a class="self-link" href="#stdLibraryUB"></a></h2>
   <p>Undefined behavior is a large topic, to make it a more tractable problem we believe tackling Core undefined behavior separately
from Library undefined behavior makes sense. Core and Library already have separate processes and tackling them seperately
will allow those with expertise in Core or Library to focus on those areas repsectively. This proposal specifically focuses
on Core while acknowledging that documenting Library undefined behavior is important, we leave that to a future proposal.</p>
   <h2 class="heading settled" data-level="11" id="trlook"><span class="secno">11. </span><span class="content">How Might the TR look</span><a class="self-link" href="#trlook"></a></h2>
   <p>There has been some effort to document core undefined behavior and below I will provide an example of one approach to
an undefined behavior TR. This works covers about most of the explicit core undefined behavior with at least one example for
each undefined behavior. To a lesser extent it covers rationales, backgrounds and tools:</p>
   <h3 class="heading settled" data-level="11.1" id="lex"><span class="secno">11.1. </span><span class="content">[lex]</span><a class="self-link" href="#lex"></a></h3>
   <h4 class="heading settled" data-level="11.1.1" id="lexphases"><span class="secno">11.1.1. </span><span class="content">[lex.phases]</span><a class="self-link" href="#lexphases"></a></h4>
   <ul>
    <li data-md>
     <p>if a splice results in a character sequence that matches the syntax of a universal-character-name, the behavior is undefined.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/lex.phases#1.2">lex.phases p1.2</a></p>
    <li data-md>
     <p>Example from <a href="https://stackoverflow.com/q/43824729/1708801">Stack Overflow question</a>:</p>
<pre class="language-cpp highlight">  <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>p</c-> <c- o>=</c-> <c- s>"</c-><c- se>\\</c->
  <c- n>u0041</c-><c- s>";</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/xZLefc">Examples live</a></p>
    <li data-md>
     <p>Rationale</p>
     <ul>
      <li data-md>
       <p><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#787">DR 787</a></p>
      <li data-md>
       <p><a href="http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3881.pdf">N3881 “Fixing the specification of universal-character-names”</a></p>
     </ul>
    <li data-md>
     <p>If a character sequence that matches the syntax of a universal-character-name is produced by token concatenation (19.3.3), the behavior is undefined. <em>\[lex.phases\]/p4</em></p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/lex.phases#1.4">lex.phases p1.4</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- cp>#define GUARD_NAME ï ## _GUARD </c-><c- c1>// UB per current spec</c->
  <c- cp>#define COLUMN "ï" ## _column </c-><c- c1>// UB per current spec</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/BO8PGi">Examples live</a></p>
    <li data-md>
     <p>Rationale</p>
     <ul>
      <li data-md>
       <p><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#787">DR 787</a></p>
      <li data-md>
       <p><a href="http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3881.pdf">N3881 “Fixing the specification of universal-character-names”</a></p>
     </ul>
   </ul>
   <h4 class="heading settled" data-level="11.1.2" id="lexstring"><span class="secno">11.1.2. </span><span class="content">[lex.string]</span><a class="self-link" href="#lexstring"></a></h4>
   <ul>
    <li data-md>
     <p>The effect of attempting to modify a string literal is undefined</p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>const</c-> <c- b>char</c-> <c- o>*</c-><c- n>p1</c-> <c- o>=</c-> <c- s>"hello world</c-><c- se>\n</c-><c- s>"</c-><c- p>;</c-> 
  <c- b>char</c-> <c- o>*</c-><c- n>p2</c-> <c- o>=</c-> <c- k>const_cast</c-><c- o>&lt;</c-><c- b>char</c-><c- o>*></c-><c- p>(</c-><c- n>p1</c-><c- p>)</c-> <c- p>;</c->   <c- c1>// const_cast is already suspicious</c->
    
  <c- n>p2</c-><c- p>[</c-><c- mi>0</c-><c- p>]</c-> <c- o>=</c-> <c- sc>'m'</c-> <c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/wrNAzz">Examples live</a></p>
    <li data-md>
     <p>Rationale [lex.string]p8</p>
     <blockquote>
      <p>Ordinary string literals and UTF-8 string literals are also referred to as narrow string literals. A narrow
string literal <strong>has type “array of n const char”</strong>, where n is the size of the string as defined below, and has
static storage duration (6.6.4).</p>
     </blockquote>
   </ul>
   <h3 class="heading settled" data-level="11.2" id="basic"><span class="secno">11.2. </span><span class="content">[basic]</span><a class="self-link" href="#basic"></a></h3>
   <h4 class="heading settled" data-level="11.2.1" id="basicdefodr"><span class="secno">11.2.1. </span><span class="content">[basic.def.odr]</span><a class="self-link" href="#basicdefodr"></a></h4>
   <ul>
    <li data-md>
     <p>There can be more than one definition of a class type (Clause 12), enumeration type (10.2), inline function with external linkage (10.1.6), inline variable with external linkage (10.1.6), class template (Clause 17), non-static function template (17.6.6), concept (17.6.8), static data member of a class template (17.6.1.3), member function of a class template (17.6.1.1), or template specialization for which some template parameters are not specified (17.8, 17.6.5) in a program provided that each definition appears in a different translation unit, and provided the definitions satisfy the following requirements. Given such an entity named D defined in more than one translation unit, then ... If the definitions of D do not satisfy these requirements, then the behavior is undefined.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/basic.def.odr#12">basic.def.odr p12</a></p>
    <li data-md>
     <p><a href="https://wiki.sei.cmu.edu/confluence/display/cplusplus/DCL60-CPP.+Obey+the+one-definition+rule">Examples from: DCL60-CPP. Obey the one-definition rule</a></p>
<pre class="language-cpp highlight">    <c- c1>// a.cpp</c->
    <c- k>struct</c-> <c- n>S</c-> <c- p>{</c->
      <c- b>int</c-> <c- n>a</c-><c- p>;</c->
    <c- p>};</c->

    <c- c1>// b.cpp</c->
    <c- c1>// S in b.cpp does not consist of the same sequence of token as S in a.cpp</c->
    <c- k>class</c-> <c- nc>S</c-> <c- p>{</c->
    <c- k>public</c-><c- o>:</c->
      <c- b>int</c-> <c- n>a</c-><c- p>;</c->
    <c- p>};</c->
</pre>
<pre class="language-cpp highlight">    <c- k>const</c-> <c- b>int</c-> <c- n>n</c-> <c- o>=</c-> <c- mi>42</c-><c- p>;</c->

    <c- b>int</c-> <c- nf>g</c-><c- p>(</c-><c- k>const</c-> <c- b>int</c-> <c- o>&amp;</c-><c- n>lhs</c-><c- p>,</c-> <c- k>const</c-> <c- b>int</c-> <c- o>&amp;</c-><c- n>rhs</c-><c- p>);</c->

    <c- kr>inline</c-> <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- b>int</c-> <c- n>k</c-><c- p>)</c-> <c- p>{</c->
      <c- k>return</c-> <c- n>g</c-><c- p>(</c-><c- n>k</c-><c- p>,</c-> <c- n>n</c-><c- p>);</c->   <c- c1>// f() has external linkage </c->
             <c- c1>// n has internal linkage but is our-used by g() </c->
                                <c- c1>// n will not be identical in all transition units</c->
    <c- p>}</c->
</pre>
    <li data-md>
     <p>Rationale:</p>
     <ul>
      <li data-md>
       <p><a href="http://hubicka.blogspot.com/2014/09/devirtualization-in-c-part-6-enforcing.html">Devirtualization in C++, part 7 (Enforcing One Definition Rule) </a></p>
     </ul>
   </ul>
   <h4 class="heading settled" data-level="11.2.2" id="basiclife"><span class="secno">11.2.2. </span><span class="content">[basic.life]</span><a class="self-link" href="#basiclife"></a></h4>
   <ul>
    <li data-md>
     <p>A program may end the lifetime of any object by reusing the storage which the object occupies or by explicitly calling the
destructor for an object of a class type with a non-trivial destructor. For an object of a class type with a non-trivial destructor,
the program is not required to call the destructor explicitly before the storage which the object occupies is reused or released;
however, <strong>if there is no explicit call to the destructor or if a delete-expression ([expr.delete]) is not used to release the storage,
the destructor shall not be implicitly called and any program that depends on the side effects produced by the destructor has undefined behavior.</strong></p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/basic.life#5">basic.life p5</a></p>
    <li data-md>
     <p><a href="https://github.com/cplusplus/draft/pull/2342">Pull request 2342 indicates this may not be undefined behavior at all</a> and seeks the following edit<br> <s>implicitly called and any program that depends on the side effects produced by the destructor has undefined behavior</s><u>implicitly called</u>.</p>
   </ul>
   <h4 class="heading settled" data-level="11.2.3" id="basicindet"><span class="secno">11.2.3. </span><span class="content">[basic.indet]</span><a class="self-link" href="#basicindet"></a></h4>
   <ul>
    <li data-md>
     <p>If an indeterminate value is produced by an evaluation, the behavior is undefined except in the following
cases</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/basic.indet#2">basic.indet p2</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- b>bool</c-> <c- n>b</c-><c- p>)</c-> <c- p>{</c->
    <c- b>unsigned</c-> <c- b>char</c-> <c- n>c</c-><c- p>;</c->
    <c- b>unsigned</c-> <c- b>char</c-> <c- n>d</c-> <c- o>=</c-> <c- n>c</c-><c- p>;</c-> <c- c1>// OK, d has an indeterminate value</c->
    <c- b>int</c-> <c- n>e</c-> <c- o>=</c-> <c- n>d</c-><c- p>;</c-> <c- c1>// undefined behavior</c->
    <c- k>return</c-> <c- n>b</c-> <c- o>?</c-> <c- nl>d</c-> <c- p>:</c-> <c- mi>0</c-><c- p>;</c-> <c- c1>// undefined behavior if b is true</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p>Rationale</p>
     <ul>
      <li data-md>
       <p><a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_260.htm">WG14 Defect report 260</a></p>
      <li data-md>
       <p><a href="http://www.open-std.org/Jtc1/sc22/WG14/www/docs/dr_451.htm">WG14 Defect report 451</a></p>
      <li data-md>
       <p>Tl;DR; We have two case one in which using an indeterminate value is undefined behavior and this is because many type can have trap representations and using these value are undefined behavior. In the case of narrow character types the underlying values and type representation are one to one and therefore we don’t have a trap representation but they do retain their indeterminateness.</p>
     </ul>
   </ul>
   <h4 class="heading settled" data-level="11.2.4" id="basicstart"><span class="secno">11.2.4. </span><span class="content">[basic.start]</span><a class="self-link" href="#basicstart"></a></h4>
   <ul>
    <li data-md>
     <p>An implementation shall not predefine the main function. This function shall not be overloaded. Its type shall have C++ language linkage and it shall have a declared return type of type int, but otherwise its type is implementation-defined.</p>
     <ul>
      <li data-md>
       <p><a href="http://eel.is/c++draft/basic.start#main-2">basic.start.main p2</a></p>
      <li data-md>
       <p>Examples:</p>
<pre class="language-cpp highlight">    <c- b>void</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{}</c->
</pre>
      <li data-md>
       <p>Tools</p>
      <li data-md>
       <p><a href="https://wandbox.org/permlink/9YlvHEA88lS0CbvV">Compiler static analysis, generates warnings or errors for void main</a></p>
     </ul>
    <li data-md>
     <p>The function main shall not be used within a program</p>
     <ul>
      <li data-md>
       <p><a href="http://eel.is/c++draft/basic.start#main-3">basic.start.main p3</a></p>
      <li data-md>
       <p>Examples:</p>
      <li data-md>
       <p><a href="https://stackoverflow.com/q/15525613/1708801">Is it illegal to take address of main() function?</a></p>
      <li data-md>
       <p><a href="https://stackoverflow.com/q/25297257/1708801">Why does gcc warn about decltype(main()) but not clang?</a></p>
     </ul>
<pre class="language-cpp highlight">      <c- n>printf</c-><c- p>(</c-> “<c- o>%</c-><c- n>p</c->\<c- n>n</c->”<c- p>,</c-> <c- o>&amp;</c-><c- n>main</c-> <c- p>)</c-> <c- p>;</c->
      <c- k>decltype</c-><c- p>(</c-><c- n>main</c-><c- p>())</c-> <c- n>x</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c->
</pre>
<pre class="language-cpp highlight">      <c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
        <c- n>std</c-><c- o>::</c-><c- n>cout</c-> <c- o>&lt;&lt;</c-> <c- k>reinterpret_cast</c-><c- o>&lt;</c-><c- b>void</c-><c- o>*></c-><c- p>(</c-><c- o>&amp;</c-><c- n>main</c-><c- p>)</c-> <c- p>;</c->
      <c- p>}</c->
</pre>
    <li data-md>
     <p>Tools</p>
     <ul>
      <li data-md>
       <p><a href="https://wandbox.org/permlink/atm7dJ1LXaVBkCsU">Compiler static analysis via -pedantic flag gcc/clang for taking address of main</a></p>
      <li data-md>
       <p><a href="https://wandbox.org/permlink/WvPFbU4hteDOX4w2">Compiler static analysis via -pedantic flag gcc/clang decltype main</a></p>
     </ul>
    <li data-md>
     <p>Rationale:</p>
     <ul>
      <li data-md>
       <p>From ARM section 3.4 Start and Termination</p>
       <blockquote>
        <p>This is to ensure full freedom of the implementation of the interface between a C++ program and its environment.
One could imagine an implementation where main() was not implemented as a function.</p>
       </blockquote>
      <li data-md>
       <p><a href="http://www.open-std.org/pipermail/ub/2014-January/000474.html">What does "The function main shall not be used within a program" mean?</a></p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="11.3" id="expr"><span class="secno">11.3. </span><span class="content">[expr]</span><a class="self-link" href="#expr"></a></h3>
   <h4 class="heading settled" data-level="11.3.1" id="exprpre"><span class="secno">11.3.1. </span><span class="content">[expr.pre]</span><a class="self-link" href="#exprpre"></a></h4>
   <ul>
    <li data-md>
     <p>Signed integer overflow/underflow is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr#pre-4">expr.pre</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">    <c- b>int</c-> <c- n>x1</c-><c- o>=</c-><c- n>std</c-><c- o>::</c-><c- n>numeric_limits</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>::</c-><c- n>max</c-><c- p>()</c-><c- o>+</c-><c- mi>1</c-><c- p>;</c->
    <c- b>int</c-> <c- n>x2</c-><c- o>=</c-><c- n>std</c-><c- o>::</c-><c- n>numeric_limits</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>::</c-><c- n>min</c-><c- p>()</c-><c- o>-</c-><c- mi>1</c-><c- p>;</c->
    <c- b>int</c-> <c- n>x3</c-><c- o>=</c-><c- n>std</c-><c- o>::</c-><c- n>numeric_limits</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>::</c-><c- n>min</c-><c- p>()</c-> <c- o>/</c-> <c- o>-</c-><c- mi>1</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/4M9uR7">Examples live 1</a> and <a href="https://godbolt.org/z/3ToiDL">examples live 2</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.2" id="convdouble"><span class="secno">11.3.2. </span><span class="content">[conv.double]</span><a class="self-link" href="#convdouble"></a></h4>
   <ul>
    <li data-md>
     <p>Converting floating point value to type that cannot represent the value is undefined behavior even for float</p>
    <li data-md>
     <p><a href="https://timsong-cpp.github.io/cppwp/n4659/conv.double#1">conv.double p1</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">    <c- b>double</c-> <c- n>d2</c-><c- o>=</c-><c- n>DBL_MAX</c-><c- p>;</c->
    <c- b>float</c-> <c- n>f</c-><c- o>=</c-><c- n>d2</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/p1y5JK">examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.3" id="convfpint"><span class="secno">11.3.3. </span><span class="content">[conv.fpint]</span><a class="self-link" href="#convfpint"></a></h4>
   <ul>
    <li data-md>
     <p>Converting floating point value to an integral that cannot represent the value is undefined behavior</p>
    <li data-md>
     <p><a href="https://timsong-cpp.github.io/cppwp/n4659/conv.fpint#1">conv.fpint p1</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">    <c- b>double</c-> <c- n>d</c-><c- o>=</c-><c- p>(</c-><c- b>double</c-><c- p>)</c-><c- n>INT_MAX</c-><c- o>+</c-><c- mi>1</c-><c- p>;</c->
    <c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- n>d</c-><c- p>;</c->
</pre>
     <ul>
      <li data-md>
       <p><a href="https://godbolt.org/z/8p0t_C">Examples live</a></p>
     </ul>
   </ul>
   <h4 class="heading settled" data-level="11.3.4" id="exprcall"><span class="secno">11.3.4. </span><span class="content">[expr.call]</span><a class="self-link" href="#exprcall"></a></h4>
   <ul>
    <li data-md>
     <p>Calling a function through an expression whose function type is different from the function type of the called
function’s definition results in undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.call#6">expr.call p6</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- nf>f_c</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->

  <c- k>using</c-> <c- n>c1</c-> <c- o>=</c-> <c- b>int</c-><c- p>(</c-><c- o>*</c-><c- p>)(</c-><c- b>int</c-><c- p>);</c->
  <c- k>using</c-> <c- n>c2</c-> <c- o>=</c-> <c- b>int</c-><c- p>(</c-><c- o>*</c-><c- p>)(</c-><c- b>int</c-><c- p>,</c-><c- b>int</c-><c- p>);</c->

  <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- n>c2</c-> <c- n>func</c-><c- p>)</c-> <c- p>{</c->
   <c- k>return</c-> <c- n>func</c-><c- p>(</c-><c- mi>1</c-><c- p>,</c-><c- mi>2</c-><c- p>);</c->
  <c- p>}</c->

  <c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>f</c-><c- p>(</c-><c- k>reinterpret_cast</c-><c- o>&lt;</c-><c- n>c2</c-><c- o>></c-><c- p>(</c-><c- n>f_c</c-><c- p>));</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://gcc.godbolt.org/z/2gUEol">Examples  live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.5" id="exprstaticcast"><span class="secno">11.3.5. </span><span class="content">[expr.static.cast]</span><a class="self-link" href="#exprstaticcast"></a></h4>
   <ul>
    <li data-md>
     <p>If the object of type “cv1 B” is actually a base class subobject of an object of type D, the result refers to the
enclosing object of type D. Otherwise, the behavior is undefined.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.static.cast#2">expr.static.cast</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>B</c-> <c- p>{};</c->
  <c- k>struct</c-> <c- nl>D1</c-><c- p>:</c-><c- n>B</c-> <c- p>{};</c->
  <c- k>struct</c-> <c- nl>D2</c-><c- p>:</c-><c- n>B</c-> <c- p>{};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
   <c- n>D1</c-> <c- n>d</c-><c- p>;</c->
   <c- n>B</c-> <c- o>&amp;</c-><c- n>b</c-> <c- o>=</c-> <c- n>d</c-><c- p>;</c->
   <c- k>static_cast</c-><c- o>&lt;</c-><c- n>D2</c-><c- o>&amp;></c-><c- p>(</c-><c- n>b</c-><c- p>);</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/z7RTFJ">Examples live</a></p>
    <li data-md>
     <p>Setting an enum to a value outside the range of enumerators is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.static.cast#10">expr.static.cast p10</a> and [\[dcl.enum\]p8](http://eel.is/c++draft/dcl.enum#8)</p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- k>enum</c-> <c- n>A</c-> <c- p>{</c-><c- n>e1</c-><c- o>=</c-><c- mi>1</c-><c- p>,</c-> <c- n>e2</c-><c- p>};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- k>enum</c-> <c- n>A</c-> <c- n>a</c-><c- o>=</c-><c- k>static_cast</c-><c- o>&lt;</c-><c- n>A</c-><c- o>></c-><c- p>(</c-><c- mi>4</c-><c- p>);</c->   
  <c- p>}</c-> 
</pre>
    <li data-md>
     <p><a href="https://wandbox.org/permlink/YWXO1IQt3DLSSHmb">Examples live</a></p>
    <li data-md>
     <p>Down-casting to the wrong derived type is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.static.cast#11">expr.static.cast p11</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>B</c-> <c- p>{};</c->
  <c- k>struct</c-> <c- nl>D1</c-><c- p>:</c-><c- n>B</c-> <c- p>{};</c->
  <c- k>struct</c-> <c- nl>D2</c-><c- p>:</c-><c- n>B</c-> <c- p>{};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- n>B</c-><c- o>*</c-> <c- n>bp</c-> <c- o>=</c-> <c- k>new</c-> <c- n>D1</c-><c- p>;</c->
    <c- k>static_cast</c-><c- o>&lt;</c-><c- n>D2</c-><c- o>*></c-><c- p>(</c-><c- n>bp</c-><c- p>);</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/gfT5Bw">Examples lives</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.6" id="exprdelete"><span class="secno">11.3.6. </span><span class="content">[expr.delete]</span><a class="self-link" href="#exprdelete"></a></h4>
   <ul>
    <li data-md>
     <p>Using array delete on the result of a single object new expression and vice versa is undefined behavior</p>
    <li data-md>
     <p>[expr.delete p2])http://eel.is/c++draft/expr.delete#2)</p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- o>*</c-><c- n>x</c-> <c- o>=</c-> <c- k>new</c-> <c- b>int</c-><c- p>;</c->
  <c- k>delete</c-> <c- p>[]</c-> <c- n>x</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/KI8XSc">Examples live</a></p>
    <li data-md>
     <p>If the dynamic type differs from the static type of the object being deleted that is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.delete#3">expr.delete p3</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- o>*</c-><c- n>p</c-> <c- o>=</c-> <c- k>new</c-> <c- b>int</c-><c- p>;</c->
  <c- b>float</c-> <c- o>*</c-><c- n>f</c-> <c- o>=</c-> <c- k>reinterpret_cast</c-><c- o>&lt;</c-><c- b>float</c-><c- o>*></c-><c- p>(</c-><c- n>p</c-><c- p>);</c->
  <c- k>delete</c-> <c- n>f</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/Pj_Ljb">Examples lives</a></p>
    <li data-md>
     <p>Deleting and incomplete type and the class turns out to have a non-trivial destructor is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.delete#5">expr.delete p5</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>A</c-><c- p>;</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>(</c-><c- n>A</c-> <c- o>*</c-><c- n>p</c-><c- p>)</c-> <c- p>{</c->
    <c- k>delete</c-> <c- n>p</c-><c- p>;</c->
  <c- p>}</c->

  <c- k>struct</c-> <c- n>A</c-> <c- p>{</c-><c- o>~</c-><c- n>A</c-><c- p>(){}};</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/Jc6lKv">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.7" id="exprmptroper"><span class="secno">11.3.7. </span><span class="content">[expr.mptr.oper]</span><a class="self-link" href="#exprmptroper"></a></h4>
   <ul>
    <li data-md>
     <p>If the dynamic type of E1 does not contain the member to which E2 refers, the behavior is undefined</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.mptr.oper#4">expr.mptr.oper p4</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>B</c-><c- p>{};</c->
  <c- k>struct</c-> <c- nl>D</c-><c- p>:</c-><c- n>B</c-><c- p>{</c-><c- b>int</c-> <c- n>x</c-><c- p>;};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>(){</c->
   <c- n>B</c-> <c- o>*</c-><c- n>b</c-><c- o>=</c-> <c- k>new</c-> <c- n>B</c-><c- p>;</c->
   <c- n>D</c-> <c- o>*</c-><c- n>d</c-><c- o>=</c-><c- k>static_cast</c-><c- o>&lt;</c-><c- n>D</c-><c- o>*></c-><c- p>(</c-><c- n>b</c-><c- p>);</c->
   <c- b>int</c-> <c- n>D</c-><c- o>::*</c-> <c- n>p</c-><c- o>=&amp;</c-><c- n>D</c-><c- o>::</c-><c- n>x</c-><c- p>;</c->
   <c- p>(</c-><c- o>*</c-><c- n>d</c-><c- p>).</c-><c- o>*</c-><c- n>p</c-><c- o>=</c-><c- mi>1</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/wgNkKz">Examples live</a></p>
    <li data-md>
     <p>If the second operand is the null member pointer value (7.3.12), the behavior is undefined.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.mptr.oper#6">expr.mptr.oper p6</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>S</c-> <c- p>{</c->
   <c- b>int</c-> <c- n>i</c-><c- p>;</c->
  <c- p>};</c->
  
  <c- b>void</c-> <c- nf>f</c-><c- p>()</c->
  <c- p>{</c->
   <c- n>S</c-> <c- n>cs</c-><c- p>;</c->
   <c- b>int</c-> <c- n>S</c-><c- o>::*</c-> <c- n>pm</c-> <c- o>=</c-> <c- k>nullptr</c-><c- p>;</c->
   <c- n>cs</c-><c- p>.</c-><c- o>*</c-><c- n>pm</c-> <c- o>=</c-> <c- mi>88</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.8" id="exprmul"><span class="secno">11.3.8. </span><span class="content">[expr.mul]</span><a class="self-link" href="#exprmul"></a></h4>
   <ul>
    <li data-md>
     <p>Divison by zero is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.mul#4">expr.mul p4</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- n>x</c-> <c- o>=</c-> <c- mi>1</c-><c- o>/</c-><c- mi>0</c-><c- p>;</c->
  <c- b>double</c-> <c- n>d</c-> <c- o>=</c-> <c- mf>1.0</c-><c- o>/</c-><c- mf>0.0</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/d42Fsi">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.9" id="expradd"><span class="secno">11.3.9. </span><span class="content">[expr.add]</span><a class="self-link" href="#expradd"></a></h4>
   <ul>
    <li data-md>
     <p>Incrementing pointer beyond one past the end of an array is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.add#4">expr.add p4</a> and <a href="http://eel.is/c++draft/expr.add#footnote-80">footnote</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>static</c-> <c- k>const</c-> <c- b>int</c-> <c- n>arrs</c-><c- p>[</c-><c- mi>10</c-><c- p>]{};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
   <c- k>const</c-> <c- b>int</c-><c- o>*</c-> <c- n>y</c-> <c- o>=</c-> <c- n>arrs</c-> <c- o>+</c-> <c- mi>11</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/Oo9lWi">Examples live</a></p>
    <li data-md>
     <p>Subtracting pointers that are not part of the same array is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.add#5.3">expr.add p5.3</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">   <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- b>int</c-> <c- n>x</c-><c- p>;</c->
    <c- b>int</c-> <c- n>y</c-><c- p>;</c->
    <c- b>int</c-> <c- o>*</c-><c- n>p1</c-><c- o>=&amp;</c-><c- n>x</c-><c- p>;</c->
    <c- b>int</c-> <c- o>*</c-><c- n>p2</c-><c- o>=&amp;</c-><c- n>y</c-><c- p>;</c->
    <c- n>std</c-><c- o>::</c-><c- b>ptrdiff_t</c-> <c- n>off</c-> <c- o>=</c-> <c- n>p1</c-><c- o>-</c-><c- n>p2</c-><c- p>;</c->
   <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/BxwQjE">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.10" id="exprshift"><span class="secno">11.3.10. </span><span class="content">[expr.shift]</span><a class="self-link" href="#exprshift"></a></h4>
   <ul>
    <li data-md>
     <p>Shifting by a negative amount is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.shift#1">expr.shift p1</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- n>y</c-> <c- o>=</c-> <c- mi>1</c-> <c- o>&lt;&lt;</c-> <c- o>-</c-><c- mi>1</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/op_tEL">Examples live</a></p>
    <li data-md>
     <p>Shifting by equal or greater than the bit-width of a type is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.shift#1">expr.shift p1</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- n>y1</c-> <c- o>=</c-> <c- mi>1</c-> <c- o>&lt;&lt;</c-> <c- mi>32</c-><c- p>;</c->
  <c- b>int</c-> <c- n>y2</c-> <c- o>=</c-> <c- mi>1</c-> <c- o>>></c-> <c- mi>32</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/fx156-">Examples live</a></p>
    <li data-md>
     <p>Shifting a negative signed type is undefined behavior (before C++20)</p>
    <li data-md>
     <p><a href="https://timsong-cpp.github.io/cppwp/n4659/expr.shift#2">expr.shift p2</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- n>y4</c-> <c- o>=</c-> <c- o>-</c-><c- mi>1</c-> <c- o>&lt;&lt;</c-> <c- mi>12</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/v3B1ij">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.3.11" id="exprass"><span class="secno">11.3.11. </span><span class="content">[expr.ass]</span><a class="self-link" href="#exprass"></a></h4>
   <ul>
    <li data-md>
     <p>Overlap in an assignment expression must be exact and the objects must have the same type</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/expr.ass#8">expr.ass p8</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- mi>1</c-><c- p>;</c->
  <c- b>char</c-> <c- o>*</c-><c- n>c</c-><c- o>=</c-><c- k>reinterpret_cast</c-><c- o>&lt;</c-><c- b>char</c-><c- o>*></c-><c- p>(</c-><c- o>&amp;</c-><c- n>x</c-><c- p>);</c->
  <c- n>x</c-> <c- o>=</c-> <c- o>*</c-><c- n>c</c-><c- p>;</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/LGBL7k">Examples live</a></p>
   </ul>
   <h3 class="heading settled" data-level="11.4" id="stmtstmt"><span class="secno">11.4. </span><span class="content">[stmt.stmt]</span><a class="self-link" href="#stmtstmt"></a></h3>
   <h4 class="heading settled" data-level="11.4.1" id="stmtreturn"><span class="secno">11.4.1. </span><span class="content">[stmt.return]</span><a class="self-link" href="#stmtreturn"></a></h4>
   <ul>
    <li data-md>
     <p>Flowing off the end of a value returning function is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/stmt.return#2.sentence-8">stmt.return p2</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- b>int</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c->
  <c- k>if</c-><c- p>(</c-><c- n>x</c-><c- p>)</c->
    <c- k>return</c-> <c- mi>1</c-><c- p>;</c->
  <c- p>}</c->
 
  <c- b>void</c-> <c- nf>b</c-><c- p>(){</c->
   <c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- n>f</c-><c- p>(</c-><c- mi>0</c-><c- p>);</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/62CGnB">Examples live</a></p>
    <li data-md>
     <p><a href="https://twitter.com/shafikyaghmour/status/975224687444688896">Also see</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.4.2" id="stmtdcl"><span class="secno">11.4.2. </span><span class="content">[stmt.dcl]</span><a class="self-link" href="#stmtdcl"></a></h4>
   <ul>
    <li data-md>
     <p>Recursively entering declaration of a block scope static variable during initialization is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/stmt.dcl#4">stmt.dcl p4</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- nf>foo</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>)</c-> <c- p>{</c->
  <c- k>static</c-> <c- b>int</c-> <c- n>s</c-> <c- o>=</c-> <c- n>foo</c-><c- p>(</c-><c- mi>2</c-><c- o>*</c-><c- n>i</c-><c- p>);</c->
  <c- k>return</c-> <c- n>i</c-><c- o>+</c-><c- mi>1</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/mT9a-_">Examples live</a></p>
   </ul>
   <h3 class="heading settled" data-level="11.5" id="dcldcl"><span class="secno">11.5. </span><span class="content">[dcl.dcl]</span><a class="self-link" href="#dcldcl"></a></h3>
   <h4 class="heading settled" data-level="11.5.1" id="dcltypecv"><span class="secno">11.5.1. </span><span class="content">[dcl.type.cv]</span><a class="self-link" href="#dcltypecv"></a></h4>
   <ul>
    <li data-md>
     <p>Attempting to modify a const object is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/dcl.type.cv#4">dcl.type.cv p4</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- nf>bar</c-><c- p>()</c-> <c- p>{</c->
  <c- k>const</c-> <c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- mi>1</c-><c- p>;</c->

  <c- b>int</c-> <c- o>*</c-><c- n>p</c-> <c- o>=</c-> <c- k>const_cast</c-><c- o>&lt;</c-><c- b>int</c-><c- o>*></c-><c- p>(</c-><c- o>&amp;</c-><c- n>x</c-><c- p>);</c->
  <c- o>*</c-><c- n>p</c-> <c- o>=</c-> <c- mi>2</c-><c- p>;</c->

  <c- k>return</c-> <c- o>*</c-><c- n>p</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/MArrbe">Examples live</a></p>
    <li data-md>
     <p>Accessing a volatile value through a non-volatile is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/dcl.spec#dcl.type.cv-5">dcl.type.cv p5</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
  <c- k>volatile</c-> <c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- mi>0</c-><c- p>;</c->
  <c- b>int</c-> <c- o>&amp;</c-><c- n>y</c-><c- o>=</c-><c- k>const_cast</c-><c- o>&lt;</c-><c- b>int</c-><c- o>&amp;></c-><c- p>(</c-><c- n>x</c-><c- p>);</c->
  <c- n>std</c-><c- o>::</c-><c- n>cout</c-> <c- o>&lt;&lt;</c-> <c- n>y</c-><c- p>;</c->
  <c- p>}</c->
</pre>
      -<a href="https://godbolt.org/z/4xKsxy">Examples live</a> 
   </ul>
   <h4 class="heading settled" data-level="11.5.2" id="dclattrcontractsyn"><span class="secno">11.5.2. </span><span class="content">[dcl.attr.contract.syn]</span><a class="self-link" href="#dclattrcontractsyn"></a></h4>
   <ul>
    <li data-md>
     <p>In contracts side effects in a predicate to an object whose lifetime did not begin and end within the evaluation of the predicate are undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/dcl.attr.contract#syn-6">dcl.attr.contract.syn p6</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- n>min</c-> <c- o>=</c-> <c- o>-</c-><c- mi>42</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- b>int</c-> <c- nf>g</c-><c- p>(</c-><c- b>int</c-> <c- n>x</c-><c- p>)</c-> <c- p>{</c->
    <c- d>/* ... */</c->
    <c- p>[[</c-><c- nl>assert</c-><c- p>:</c-> <c- o>++</c-><c- n>min</c-> <c- o>></c-> <c- mi>0</c-><c- p>]];</c-> <c- c1>// undefined behavior</c->
    <c- d>/* ... */</c->
    <c- k>return</c-> <c- mi>0</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="http://fragata.arcos.inf.uc3m.es/#g:!((g:!((g:!((h:codeEditor,i:(j:1,lang:c%2B%2B,source:&apos;int+min+%3D+-42%3B%0Aconstexpr+int+g(int+x">Examples live</a>%7B%0A++/<em>+...+</em>/%0A++%5B%5Bassert:+%2B%2Bmin+%3E+0%5D%5D%3B+//+undefined+behavior%0A++/<em>+...+</em>/%0A++return+0%3B%0A%7D'),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'C%2B%2B+source+%231',t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">4</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,s:0,t:<a class="property" data-link-type="propdesc">0</a>),(g:!((g:!((h:compiler,i:(compiler:clang%2B%2B-master,filters:(b:<a class="property" data-link-type="propdesc">0</a>,binary:<a class="property" data-link-type="propdesc">1</a>,commentOnly:<a class="property" data-link-type="propdesc">0</a>,demangle:<a class="property" data-link-type="propdesc">0</a>,directives:<a class="property" data-link-type="propdesc">0</a>,execute:<a class="property" data-link-type="propdesc">1</a>,intel:<a class="property" data-link-type="propdesc">0</a>,trim:<a class="property" data-link-type="propdesc">0</a>),lang:c%2B%2B,libs:!(),options:</span>,source:1),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'Clang+6.0.0+x86_64+%5Bclang-contracts%5D+(master)+(Editor+%231,+Compiler+%231)+C%2B%2B',t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">4</a>,m:50,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,s:0,t:<a class="property" data-link-type="propdesc">0</a>),(g:!((h:output,i:(compiler:1,editor:1),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'%231+with+Clang+6.0.0+x86_64+%5Bclang-contracts%5D+(master)',t:<a class="property" data-link-type="propdesc">0</a>)),header:(),l:<a class="property" data-link-type="propdesc">4</a>,m:50,n:<a class="property" data-link-type="propdesc">0</a>,o:</span>,s:0,t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">3</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,t:<a class="property" data-link-type="propdesc">0</a>)),l:<a class="property" data-link-type="propdesc">2</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:</span>,t:<a class="property" data-link-type="propdesc">0</a>)),version:4)</p>
   </ul>
   <h4 class="heading settled" data-level="11.5.3" id="dclattrcontractsyn①"><span class="secno">11.5.3. </span><span class="content">[dcl.attr.contract.syn]</span><a class="self-link" href="#dclattrcontractsyn①"></a></h4>
   <ul>
    <li data-md>
     <p>if a postcondition odr-uses a non-reference parameter in its predicate and the function body makes direct or indirect modifications of the value of that parameter, the behavior is undefined.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/dcl.attr.contract#cond-7">dcl.attr.contract.cond p7</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- b>int</c-> <c- n>x</c-><c- p>)</c->
  <c- p>[[</c-><c- n>ensures</c-> <c- nl>r</c-><c- p>:</c-> <c- n>r</c-> <c- o>==</c-> <c- n>x</c-><c- p>]]</c->
  <c- p>{</c->
    <c- k>return</c-> <c- o>++</c-><c- n>x</c-><c- p>;</c-> <c- c1>// UB</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="http://fragata.arcos.inf.uc3m.es/#g:!((g:!((g:!((h:codeEditor,i:(j:1,lang:c%2B%2B,source:&apos;int+f(int+x">Examples live</a>%0A++%5B%5Bensures+r:+r+%3D%3D+x%5D%5D%0A%7B%0A++return+%2B%2Bx%3B+//+UB%0A%7D%0A'),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'C%2B%2B+source+%231',t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">4</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,s:0,t:<a class="property" data-link-type="propdesc">0</a>),(g:!((g:!((h:compiler,i:(compiler:clang%2B%2B-master,filters:(b:<a class="property" data-link-type="propdesc">0</a>,binary:<a class="property" data-link-type="propdesc">1</a>,commentOnly:<a class="property" data-link-type="propdesc">0</a>,demangle:<a class="property" data-link-type="propdesc">0</a>,directives:<a class="property" data-link-type="propdesc">0</a>,execute:<a class="property" data-link-type="propdesc">1</a>,intel:<a class="property" data-link-type="propdesc">0</a>,trim:<a class="property" data-link-type="propdesc">0</a>),lang:c%2B%2B,libs:!(),options:</span>,source:1),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'Clang+6.0.0+x86_64+%5Bclang-contracts%5D+(master)+(Editor+%231,+Compiler+%231)+C%2B%2B',t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">4</a>,m:50,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,s:0,t:<a class="property" data-link-type="propdesc">0</a>),(g:!((h:output,i:(compiler:1,editor:1),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'%231+with+Clang+6.0.0+x86_64+%5Bclang-contracts%5D+(master)',t:<a class="property" data-link-type="propdesc">0</a>)),header:(),l:<a class="property" data-link-type="propdesc">4</a>,m:50,n:<a class="property" data-link-type="propdesc">0</a>,o:</span>,s:0,t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">3</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,t:<a class="property" data-link-type="propdesc">0</a>)),l:<a class="property" data-link-type="propdesc">2</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:</span>,t:<a class="property" data-link-type="propdesc">0</a>)),version:4)</p>
   </ul>
   <h4 class="heading settled" data-level="11.5.4" id="dclattrcontractcheck"><span class="secno">11.5.4. </span><span class="content">[dcl.attr.contract.check]</span><a class="self-link" href="#dclattrcontractcheck"></a></h4>
   <ul>
    <li data-md>
     <p>Violating a non-checked contract is undefined behavior outside of a constant expression context</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/dcl.attr.contract#check-4">dcl.attr.contract.check p4</a></p>
    <li data-md>
     <p>Rationale see <a href="http://open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1321r0.html">p1321r0</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1490r0.html">p1490r0</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- b>void</c-> <c- nf>f</c-><c- p>(</c-><c- b>int</c-> <c- n>x</c-><c- p>)</c-> <c- p>[[</c-><c- n>expects</c-> <c- nl>audit</c-><c- p>:</c-> <c- n>x</c-><c- o>>=</c-><c- mi>1</c-> <c- o>&amp;&amp;</c-> <c- n>x</c-><c- o>&lt;=</c-><c- mi>2</c-><c- p>]];</c->
 
  <c- b>void</c-> <c- nf>b</c-><c- p>()</c-> <c- p>{</c->
    <c- n>f</c-><c- p>(</c-><c- mi>100</c-><c- p>);</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="http://fragata.arcos.inf.uc3m.es/#g:!((g:!((g:!((h:codeEditor,i:(j:1,lang:c%2B%2B,source:&apos;void+f(int+x">Examples live</a>+%5B%5Bexpects+audit:+x%3E%3D1+%26%26+x%3C%3D2%5D%5D%3B%0A%0Avoid+b()+%7B%0A++f(100)%3B%0A%7D'),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'C%2B%2B+source+%231',t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">4</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,s:0,t:<a class="property" data-link-type="propdesc">0</a>),(g:!((g:!((h:compiler,i:(compiler:clang%2B%2B-master,filters:(b:<a class="property" data-link-type="propdesc">0</a>,binary:<a class="property" data-link-type="propdesc">1</a>,commentOnly:<a class="property" data-link-type="propdesc">0</a>,demangle:<a class="property" data-link-type="propdesc">0</a>,directives:<a class="property" data-link-type="propdesc">0</a>,execute:<a class="property" data-link-type="propdesc">1</a>,intel:<a class="property" data-link-type="propdesc">0</a>,trim:<a class="property" data-link-type="propdesc">0</a>),lang:c%2B%2B,libs:!(),options:</span>,source:1),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'Clang+6.0.0+x86_64+%5Bclang-contracts%5D+(master)+(Editor+%231,+Compiler+%231)+C%2B%2B',t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">4</a>,m:50,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,s:0,t:<a class="property" data-link-type="propdesc">0</a>),(g:!((h:output,i:(compiler:1,editor:1),l:<a class="property" data-link-type="propdesc">5</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:'%231+with+Clang+6.0.0+x86_64+%5Bclang-contracts%5D+(master)',t:<a class="property" data-link-type="propdesc">0</a>)),header:(),l:<a class="property" data-link-type="propdesc">4</a>,m:50,n:<a class="property" data-link-type="propdesc">0</a>,o:</span>,s:0,t:<a class="property" data-link-type="propdesc">0</a>)),k:50,l:<a class="property" data-link-type="propdesc">3</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:<span class="css">,t:<a class="property" data-link-type="propdesc">0</a>)),l:<a class="property" data-link-type="propdesc">2</a>,n:<a class="property" data-link-type="propdesc">0</a>,o:</span>,t:<a class="property" data-link-type="propdesc">0</a>)),version:4)</p>
   </ul>
   <h4 class="heading settled" data-level="11.5.5" id="dclattrnoreturn"><span class="secno">11.5.5. </span><span class="content">[dcl.attr.noreturn]</span><a class="self-link" href="#dclattrnoreturn"></a></h4>
   <ul>
    <li data-md>
     <p>A function declared noreturn eventually returns it is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/dcl.attr.noreturn#2">dcl.attr.noreturn p2</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- p>[[</c-> <c- n>noreturn</c-> <c- p>]]</c-> <c- b>void</c-> <c- n>q</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>)</c-> <c- p>{</c-> <c- c1>// behavior is undefined if called with an argument &lt;= 0</c->
  <c- k>if</c-> <c- p>(</c-><c- n>i</c-> <c- o>></c-> <c- mi>0</c-><c- p>)</c->
    <c- k>throw</c-> <c- s>"positive"</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/_8GQBg">Examples live</a></p>
   </ul>
   <h3 class="heading settled" data-level="11.6" id="class"><span class="secno">11.6. </span><span class="content">[class]</span><a class="self-link" href="#class"></a></h3>
   <h4 class="heading settled" data-level="11.6.1" id="classmfctnon-static"><span class="secno">11.6.1. </span><span class="content">[class.mfct.non-static]</span><a class="self-link" href="#classmfctnon-static"></a></h4>
   <ul>
    <li data-md>
     <p>Calling a non-static member function of a class with an object that is not of that type is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.mem#class.mfct.non-static-2">class.mfct.non-static p2</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>X</c-> <c- p>{</c->
    <c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- mi>1</c-><c- p>;</c->
    <c- b>int</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c-> <c- k>return</c-> <c- n>x</c-><c- p>;}</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- n>A</c-> <c- p>{</c-><c- b>int</c-> <c- n>x</c-><c- o>=</c-><c- mi>3</c-><c- p>;};</c->

  <c- b>int</c-> <c- nf>f</c-><c- p>(</c-><c- n>X</c-><c- o>*</c-><c- n>x</c-><c- p>)</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>x</c-><c- o>-></c-><c- n>f</c-><c- p>();</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/0zBLzy">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.6.2" id="classdtor"><span class="secno">11.6.2. </span><span class="content">[class.dtor]</span><a class="self-link" href="#classdtor"></a></h4>
   <ul>
    <li data-md>
     <p>Explicit destructor call for an object not of the type is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.dtor#14">class.dtor p14</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>X</c-> <c- p>{};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- n>X</c-> <c- o>*</c-><c- n>x</c-><c- o>=</c-><c- k>nullptr</c-><c- p>;</c->
    <c- n>x</c-><c- o>->~</c-><c- n>X</c-><c- p>();</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/Qola5k">Examples live</a></p>
    <li data-md>
     <p>Invoking the destructor for an object once its lifetime has ended is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.dtor#16">class.dtor p16</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>A</c-><c- p>{</c->
     <c- o>~</c-><c- n>A</c-><c- p>(){}</c->
  <c- p>};</c->

  <c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>A</c-> <c- n>a</c-><c- p>;</c->
    <c- n>a</c-><c- p>.</c-><c- o>~</c-><c- n>A</c-><c- p>();</c-> <c- c1>// Destructor will be invoked again at scope exit invoking UB</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/kHMPig">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.6.3" id="classunion"><span class="secno">11.6.3. </span><span class="content">[class.union]</span><a class="self-link" href="#classunion"></a></h4>
   <ul>
    <li data-md>
     <p>Accessing a non-active union member is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.union#1">class.union p1</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>union</c-> <c- n>Y</c-> <c- p>{</c-> <c- b>float</c-> <c- n>f</c-><c- p>;</c-> <c- b>int</c-> <c- n>k</c-><c- p>;</c-> <c- p>};</c->
  <c- b>void</c-> <c- nf>g</c-><c- p>()</c-> <c- p>{</c->
   <c- n>Y</c-> <c- n>y</c-> <c- o>=</c-> <c- p>{</c-> <c- mf>1.0f</c-> <c- p>};</c-> <c- c1>// OK, y.f is active union member (10.3)</c->
   <c- b>int</c-> <c- n>n</c-> <c- o>=</c-> <c- n>y</c-><c- p>.</c-><c- n>k</c-><c- p>;</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/LbbRnS">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.6.4" id="classabstract"><span class="secno">11.6.4. </span><span class="content">[class.abstract]</span><a class="self-link" href="#classabstract"></a></h4>
   <ul>
    <li data-md>
     <p>Calling a virtual function from a constructor or destructor in an abstract class is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.derived#class.abstract-6">class.abstract p6</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>B</c-> <c- p>{</c->
   <c- k>virtual</c-> <c- b>void</c-> <c- n>f</c-><c- p>()</c-><c- o>=</c-><c- mi>0</c-><c- p>;</c->
   <c- n>B</c-><c- p>()</c-> <c- p>{</c-> <c- n>f</c-><c- p>();}</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>D</c-> <c- p>:</c-> <c- n>B</c-><c- p>{</c->
      <c- b>void</c-> <c- n>f</c-><c- p>()</c-> <c- k>override</c-> <c- p>{</c-> <c- p>}</c->
  <c- p>};</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/mFTX2B">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.6.5" id="classbaseinit"><span class="secno">11.6.5. </span><span class="content">[class.base.init]</span><a class="self-link" href="#classbaseinit"></a></h4>
   <ul>
    <li data-md>
     <p>Calling a member function before all bases are initialized is undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.base.init#16">class.base.init p16</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>B</c-> <c- p>{</c->
    <c- n>B</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>D</c-> <c- p>:</c-> <c- k>public</c-> <c- n>B</c-> <c- p>{</c->
    <c- b>int</c-> <c- n>f</c-><c- p>();</c->
    <c- n>D</c-><c- p>()</c-> <c- o>:</c-> <c- n>B</c-><c- p>(</c-><c- n>f</c-><c- p>())</c-> <c- p>{}</c->
  <c- p>};</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/um0iNu">Examples live</a></p>
   </ul>
   <h4 class="heading settled" data-level="11.6.6" id="classcdtor"><span class="secno">11.6.6. </span><span class="content">[class.cdtor]</span><a class="self-link" href="#classcdtor"></a></h4>
   <ul>
    <li data-md>
     <p>For an object with a non-trivial constructor, referring to any non-static member or base class of the object
before the constructor begins execution results in undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.cdtor#1">class.cdtor p1</a></p>
    <li data-md>
     <p>Examples</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>W</c-> <c- p>{</c-> <c- b>int</c-> <c- n>j</c-><c- p>;</c-> <c- p>};</c->
  <c- k>struct</c-> <c- nl>X</c-> <c- p>:</c-> <c- k>public</c-> <c- k>virtual</c-> <c- n>W</c-> <c- p>{</c-> <c- p>};</c->
  
  <c- k>struct</c-> <c- n>Y</c-> <c- p>{</c->
   <c- b>int</c-><c- o>*</c-> <c- n>p</c-><c- p>;</c->
   <c- n>X</c-> <c- n>x</c-><c- p>;</c-> 
   <c- n>Y</c-><c- p>()</c-> <c- o>:</c-> <c- n>p</c-><c- p>(</c-><c- o>&amp;</c-><c- n>x</c-><c- p>.</c-><c- n>j</c-><c- p>)</c-> <c- p>{</c-> <c- c1>// undefined, x is not yet constructed</c->
    <c- p>}</c->
  <c- p>};</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/fFbAY9">Examples live</a></p>
    <li data-md>
     <p>To explicitly or implicitly convert a pointer (a glvalue) referring to an object of class X to a pointer (reference)
to a direct or indirect base class B of X, the construction of X and the construction of all of its direct or
indirect bases that directly or indirectly derive from B shall have started and the destruction of these classes
shall not have completed, otherwise the conversion results in undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.cdtor#3">class.cdtor p3</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>A</c-> <c- p>{</c-> <c- p>};</c->
  <c- k>struct</c-> <c- nl>B</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>A</c-> <c- p>{</c-> <c- p>};</c->
  <c- k>struct</c-> <c- nl>C</c-> <c- p>:</c-> <c- n>B</c-> <c- p>{</c-> <c- p>};</c->
  <c- k>struct</c-> <c- nl>D</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>A</c-> <c- p>{</c-> <c- n>D</c-><c- p>(</c-><c- n>A</c-><c- o>*</c-><c- p>);</c-> <c- p>};</c->
  <c- k>struct</c-> <c- n>X</c-> <c- p>{</c-> <c- n>X</c-><c- p>(</c-><c- n>A</c-><c- o>*</c-><c- p>);</c-> <c- p>};</c->

  <c- k>struct</c-> <c- nl>E</c-> <c- p>:</c-> <c- n>C</c-><c- p>,</c-> <c- n>D</c-><c- p>,</c-> <c- n>X</c-> <c- p>{</c->
    <c- n>E</c-><c- p>()</c-> <c- o>:</c-> <c- n>D</c-><c- p>(</c-><c- k>this</c-><c- p>),</c-> <c- c1>// undefined: upcast from E* to A* might use path E* ! D* ! A*</c->
                       <c- c1>// but D is not constructed</c->

                      <c- c1>// “D((C*)this)” would be defined: E* ! C* is defined because E() has started,</c->
                     <c- c1>// and C* ! A* is defined because C is fully constructed</c->

      <c- n>X</c-><c- p>(</c-><c- k>this</c-><c- p>)</c-> <c- p>{}</c-> <c- c1>// defined: upon construction of X, C/B/D/A sublattice is fully constructed. </c->
  <c- p>};</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/Xu8yOi">Examples live</a></p>
    <li data-md>
     <p>To form a pointer to (or access the value of) a direct non-static member of an object obj, the construction of obj shall have started and its destruction shall not have completed, otherwise the computation of the pointer value (or accessing
the member value) results in undefined behavior.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.cdtor#3">class.cdtor p3</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>A</c-> <c- p>{</c->
    <c- b>int</c-> <c- n>x</c-><c- p>;</c->
  <c- p>};</c->

  <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- n>A</c-> <c- n>a</c-><c- p>;</c->
    <c- n>a</c-><c- p>.</c-><c- o>~</c-><c- n>A</c-><c- p>();</c->
    <c- b>int</c-> <c- o>*</c-><c- n>p</c-><c- o>=&amp;</c-><c- n>a</c-><c- p>.</c-><c- n>x</c-><c- p>;</c-> <c- c1>// Destruction completed so computing the pointer is undefined behavior</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/O89aee">Examples lives</a></p>
    <li data-md>
     <p>If the virtual function call uses an explicit class member access (7.6.1.4) and the object expression refers to the complete
object of x or one of that object’s base class subobjects but not x or one of its base class subobjects, the
behavior is undefined.</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.cdtor#4">class.cdtor p4</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>V</c-> <c- p>{</c->
    <c- k>virtual</c-> <c- b>void</c-> <c- n>f</c-><c- p>();</c->
    <c- k>virtual</c-> <c- b>void</c-> <c- nf>g</c-><c- p>();</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>A</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>V</c-> <c- p>{</c->
    <c- k>virtual</c-> <c- b>void</c-> <c- n>f</c-><c- p>();</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>B</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>V</c-> <c- p>{</c->
    <c- k>virtual</c-> <c- b>void</c-> <c- n>g</c-><c- p>();</c-> 
    <c- n>B</c-><c- p>(</c-><c- n>V</c-><c- o>*</c-><c- p>,</c-> <c- n>A</c-><c- o>*</c-><c- p>);</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>D</c-> <c- p>:</c-> <c- n>A</c-><c- p>,</c-> <c- n>B</c-> <c- p>{</c->
    <c- k>virtual</c-> <c- b>void</c-> <c- n>f</c-><c- p>();</c->
    <c- k>virtual</c-> <c- b>void</c-> <c- nf>g</c-><c- p>();</c->
    <c- n>D</c-><c- p>()</c-> <c- o>:</c-> <c- n>B</c-><c- p>((</c-><c- n>A</c-><c- o>*</c-><c- p>)</c-><c- k>this</c-><c- p>,</c-> <c- k>this</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->
  <c- p>};</c->

  <c- n>B</c-><c- o>::</c-><c- n>B</c-><c- p>(</c-><c- n>V</c-><c- o>*</c-> <c- n>v</c-><c- p>,</c-> <c- n>A</c-><c- o>*</c-> <c- n>a</c-><c- p>)</c-> <c- p>{</c->
    <c- n>f</c-><c- p>();</c-> <c- c1>// calls V::f, not A::f</c->
    <c- n>g</c-><c- p>();</c-> <c- c1>// calls B::g, not D::g</c->
    <c- n>v</c-><c- o>-></c-><c- n>g</c-><c- p>();</c-> <c- c1>// v is base of B, the call is well-defined, calls B::g</c->
    <c- n>a</c-><c- o>-></c-><c- n>f</c-><c- p>();</c-> <c- c1>// undefined behavior, a’s type not a base of B. </c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/-U8W-2">Examples live</a></p>
    <li data-md>
     <p>If the operand of typeid refers to the object under construction or destruction and the static type of the operand is neither the constructor or destructor’s class nor one of its bases, the behavior is undefined</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.cdtor#5">class.cdtor p5</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">  <c- k>struct</c-> <c- n>V</c-> <c- p>{</c->
   <c- k>virtual</c-> <c- b>void</c-> <c- n>f</c-><c- p>();</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>A</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>V</c-> <c- p>{</c-> <c- p>};</c->
  <c- k>struct</c-> <c- nl>B</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>V</c-> <c- p>{</c->
   <c- n>B</c-><c- p>(</c-><c- n>V</c-><c- o>*</c-><c- p>,</c-> <c- n>A</c-><c- o>*</c-><c- p>);</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>D</c-> <c- p>:</c-> <c- n>A</c-><c- p>,</c-> <c- n>B</c-> <c- p>{</c->
   <c- n>D</c-><c- p>()</c-> <c- o>:</c-> <c- n>B</c-><c- p>((</c-><c- n>A</c-><c- o>*</c-><c- p>)</c-><c- k>this</c-><c- p>,</c-> <c- k>this</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->
  <c- p>};</c->

  <c- n>B</c-><c- o>::</c-><c- n>B</c-><c- p>(</c-><c- n>V</c-><c- o>*</c-> <c- n>v</c-><c- p>,</c-> <c- n>A</c-><c- o>*</c-> <c- n>a</c-><c- p>)</c-> <c- p>{</c->
    <c- k>typeid</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>);</c-> <c- c1>// type_info for B.</c->
    <c- k>typeid</c-><c- p>(</c-><c- o>*</c-><c- n>v</c-><c- p>);</c-> <c- c1>// well-defined: *v has type V, a base of B yields type_info for B</c->
    <c- k>typeid</c-><c- p>(</c-><c- o>*</c-><c- n>a</c-><c- p>);</c-> <c- c1>// undefined behavior: type A not a base of B</c->
    <c- k>dynamic_cast</c-><c- o>&lt;</c-><c- n>B</c-><c- o>*></c-><c- p>(</c-><c- n>v</c-><c- p>);</c-> <c- c1>// well-defined: v of type V*, V base of B results in B*</c->
    <c- k>dynamic_cast</c-><c- o>&lt;</c-><c- n>B</c-><c- o>*></c-><c- p>(</c-><c- n>a</c-><c- p>);</c-> <c- c1>// undefined behavior, a has type A*, A not a base of B</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/XH7xat">Examples live</a></p>
    <li data-md>
     <p>If the operand of the dynamic_cast refers to the object under construction or destruction and the static type
of the operand is not a pointer to or object of the constructor or destructor’s own class or one of its bases,
the dynamic_cast results in undefined behavior</p>
    <li data-md>
     <p><a href="http://eel.is/c++draft/class.cdtor#6">class.cdtor p6</a></p>
    <li data-md>
     <p>Examples:</p>
<pre class="language-cpp highlight">    <c- k>struct</c-> <c- n>V</c-> <c- p>{</c->
   <c- k>virtual</c-> <c- b>void</c-> <c- n>f</c-><c- p>();</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>A</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>V</c-> <c- p>{</c-> <c- p>};</c->
  <c- k>struct</c-> <c- nl>B</c-> <c- p>:</c-> <c- k>virtual</c-> <c- n>V</c-> <c- p>{</c->
   <c- n>B</c-><c- p>(</c-><c- n>V</c-><c- o>*</c-><c- p>,</c-> <c- n>A</c-><c- o>*</c-><c- p>);</c->
  <c- p>};</c->

  <c- k>struct</c-> <c- nl>D</c-> <c- p>:</c-> <c- n>A</c-><c- p>,</c-> <c- n>B</c-> <c- p>{</c->
   <c- n>D</c-><c- p>()</c-> <c- o>:</c-> <c- n>B</c-><c- p>((</c-><c- n>A</c-><c- o>*</c-><c- p>)</c-><c- k>this</c-><c- p>,</c-> <c- k>this</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->
  <c- p>};</c->

  <c- n>B</c-><c- o>::</c-><c- n>B</c-><c- p>(</c-><c- n>V</c-><c- o>*</c-> <c- n>v</c-><c- p>,</c-> <c- n>A</c-><c- o>*</c-> <c- n>a</c-><c- p>)</c-> <c- p>{</c->
    <c- k>typeid</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>);</c-> <c- c1>// type_info for B.</c->
    <c- k>typeid</c-><c- p>(</c-><c- o>*</c-><c- n>v</c-><c- p>);</c-> <c- c1>// well-defined: *v has type V, a base of B yields type_info for B</c->
    <c- k>typeid</c-><c- p>(</c-><c- o>*</c-><c- n>a</c-><c- p>);</c-> <c- c1>// undefined behavior: type A not a base of B</c->
    <c- k>dynamic_cast</c-><c- o>&lt;</c-><c- n>B</c-><c- o>*></c-><c- p>(</c-><c- n>v</c-><c- p>);</c-> <c- c1>// well-defined: v of type V*, V base of B results in B*</c->
    <c- k>dynamic_cast</c-><c- o>&lt;</c-><c- n>B</c-><c- o>*></c-><c- p>(</c-><c- n>a</c-><c- p>);</c-> <c- c1>// undefined behavior, a has type A*, A not a base of B</c->
  <c- p>}</c->
</pre>
    <li data-md>
     <p><a href="https://godbolt.org/z/XH7xat">Examples live</a></p>
   </ul>
   <h2 class="heading settled" data-level="12" id="acknowledgement"><span class="secno">12. </span><span class="content">Acknowledgement</span><a class="self-link" href="#acknowledgement"></a></h2>
    Thanks to JF Bastien for his review. 
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

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

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

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

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

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

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


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

    tocNav.appendChild(toggle);
  }

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

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

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

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-p1705r0">[P1705R0]
   <dd>Shafik Yaghmour. <a href="https://wg21.link/p1705r0">Enumerating Core Undefined Behavior</a>. 13 June 2019. URL: <a href="https://wg21.link/p1705r0">https://wg21.link/p1705r0</a>
  </dl>