libs/smart_ptr/doc/html/smart_ptr.html

   1 <!DOCTYPE html>
   2 <html lang="en">
   3 <head>
   4 <meta charset="UTF-8">
   5 <!--[if IE]><meta http-equiv="X-UA-Compatible" content="IE=edge"><![endif]-->
   6 <meta name="viewport" content="width=device-width, initial-scale=1.0">
   7 <meta name="generator" content="Asciidoctor 1.5.8">
   8 <meta name="author" content="Greg Colvin, Beman Dawes, Peter Dimov, Glen Fernandes">
   9 <title>Boost.SmartPtr: The Smart Pointer Library</title>
  10 <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700">
  11 <style>
  12 /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */
  13 /* Uncomment @import statement below to use as custom stylesheet */
  14 /*@import "https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700";*/
  15 article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}
  16 audio,canvas,video{display:inline-block}
  17 audio:not([controls]){display:none;height:0}
  18 script{display:none!important}
  19 html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}
  20 a{background:transparent}
  21 a:focus{outline:thin dotted}
  22 a:active,a:hover{outline:0}
  23 h1{font-size:2em;margin:.67em 0}
  24 abbr[title]{border-bottom:1px dotted}
  25 b,strong{font-weight:bold}
  26 dfn{font-style:italic}
  27 hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0}
  28 mark{background:#ff0;color:#000}
  29 code,kbd,pre,samp{font-family:monospace;font-size:1em}
  30 pre{white-space:pre-wrap}
  31 q{quotes:"\201C" "\201D" "\2018" "\2019"}
  32 small{font-size:80%}
  33 sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}
  34 sup{top:-.5em}
  35 sub{bottom:-.25em}
  36 img{border:0}
  37 svg:not(:root){overflow:hidden}
  38 figure{margin:0}
  39 fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}
  40 legend{border:0;padding:0}
  41 button,input,select,textarea{font-family:inherit;font-size:100%;margin:0}
  42 button,input{line-height:normal}
  43 button,select{text-transform:none}
  44 button,html input[type="button"],input[type="reset"],input[type="submit"]{-webkit-appearance:button;cursor:pointer}
  45 button[disabled],html input[disabled]{cursor:default}
  46 input[type="checkbox"],input[type="radio"]{box-sizing:border-box;padding:0}
  47 button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}
  48 textarea{overflow:auto;vertical-align:top}
  49 table{border-collapse:collapse;border-spacing:0}
  50 *,*::before,*::after{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}
  51 html,body{font-size:100%}
  52 body{background:#fff;color:rgba(0,0,0,.8);padding:0;margin:0;font-family:"Noto Serif","DejaVu Serif",serif;font-weight:400;font-style:normal;line-height:1;position:relative;cursor:auto;tab-size:4;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased}
  53 a:hover{cursor:pointer}
  54 img,object,embed{max-width:100%;height:auto}
  55 object,embed{height:100%}
  56 img{-ms-interpolation-mode:bicubic}
  57 .left{float:left!important}
  58 .right{float:right!important}
  59 .text-left{text-align:left!important}
  60 .text-right{text-align:right!important}
  61 .text-center{text-align:center!important}
  62 .text-justify{text-align:justify!important}
  63 .hide{display:none}
  64 img,object,svg{display:inline-block;vertical-align:middle}
  65 textarea{height:auto;min-height:50px}
  66 select{width:100%}
  67 .center{margin-left:auto;margin-right:auto}
  68 .stretch{width:100%}
  69 .subheader,.admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{line-height:1.45;color:#7a2518;font-weight:400;margin-top:0;margin-bottom:.25em}
  70 div,dl,dt,dd,ul,ol,li,h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6,pre,form,p,blockquote,th,td{margin:0;padding:0;direction:ltr}
  71 a{color:#2156a5;text-decoration:underline;line-height:inherit}
  72 a:hover,a:focus{color:#1d4b8f}
  73 a img{border:none}
  74 p{font-family:inherit;font-weight:400;font-size:1em;line-height:1.6;margin-bottom:1.25em;text-rendering:optimizeLegibility}
  75 p aside{font-size:.875em;line-height:1.35;font-style:italic}
  76 h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{font-family:"Open Sans","DejaVu Sans",sans-serif;font-weight:300;font-style:normal;color:#ba3925;text-rendering:optimizeLegibility;margin-top:1em;margin-bottom:.5em;line-height:1.0125em}
  77 h1 small,h2 small,h3 small,#toctitle small,.sidebarblock>.content>.title small,h4 small,h5 small,h6 small{font-size:60%;color:#e99b8f;line-height:0}
  78 h1{font-size:2.125em}
  79 h2{font-size:1.6875em}
  80 h3,#toctitle,.sidebarblock>.content>.title{font-size:1.375em}
  81 h4,h5{font-size:1.125em}
  82 h6{font-size:1em}
  83 hr{border:solid #dddddf;border-width:1px 0 0;clear:both;margin:1.25em 0 1.1875em;height:0}
  84 em,i{font-style:italic;line-height:inherit}
  85 strong,b{font-weight:bold;line-height:inherit}
  86 small{font-size:60%;line-height:inherit}
  87 code{font-family:"Droid Sans Mono","DejaVu Sans Mono",monospace;font-weight:400;color:rgba(0,0,0,.9)}
  88 ul,ol,dl{font-size:1em;line-height:1.6;margin-bottom:1.25em;list-style-position:outside;font-family:inherit}
  89 ul,ol{margin-left:1.5em}
  90 ul li ul,ul li ol{margin-left:1.25em;margin-bottom:0;font-size:1em}
  91 ul.square li ul,ul.circle li ul,ul.disc li ul{list-style:inherit}
  92 ul.square{list-style-type:square}
  93 ul.circle{list-style-type:circle}
  94 ul.disc{list-style-type:disc}
  95 ol li ul,ol li ol{margin-left:1.25em;margin-bottom:0}
  96 dl dt{margin-bottom:.3125em;font-weight:bold}
  97 dl dd{margin-bottom:1.25em}
  98 abbr,acronym{text-transform:uppercase;font-size:90%;color:rgba(0,0,0,.8);border-bottom:1px dotted #ddd;cursor:help}
  99 abbr{text-transform:none}
 100 blockquote{margin:0 0 1.25em;padding:.5625em 1.25em 0 1.1875em;border-left:1px solid #ddd}
 101 blockquote cite{display:block;font-size:.9375em;color:rgba(0,0,0,.6)}
 102 blockquote cite::before{content:"\2014 \0020"}
 103 blockquote cite a,blockquote cite a:visited{color:rgba(0,0,0,.6)}
 104 blockquote,blockquote p{line-height:1.6;color:rgba(0,0,0,.85)}
 105 @media screen and (min-width:768px){h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{line-height:1.2}
 106 h1{font-size:2.75em}
 107 h2{font-size:2.3125em}
 108 h3,#toctitle,.sidebarblock>.content>.title{font-size:1.6875em}
 109 h4{font-size:1.4375em}}
 110 table{background:#fff;margin-bottom:1.25em;border:solid 1px #dedede}
 111 table thead,table tfoot{background:#f7f8f7}
 112 table thead tr th,table thead tr td,table tfoot tr th,table tfoot tr td{padding:.5em .625em .625em;font-size:inherit;color:rgba(0,0,0,.8);text-align:left}
 113 table tr th,table tr td{padding:.5625em .625em;font-size:inherit;color:rgba(0,0,0,.8)}
 114 table tr.even,table tr.alt,table tr:nth-of-type(even){background:#f8f8f7}
 115 table thead tr th,table tfoot tr th,table tbody tr td,table tr td,table tfoot tr td{display:table-cell;line-height:1.6}
 116 h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{line-height:1.2;word-spacing:-.05em}
 117 h1 strong,h2 strong,h3 strong,#toctitle strong,.sidebarblock>.content>.title strong,h4 strong,h5 strong,h6 strong{font-weight:400}
 118 .clearfix::before,.clearfix::after,.float-group::before,.float-group::after{content:" ";display:table}
 119 .clearfix::after,.float-group::after{clear:both}
 120 *:not(pre)>code{font-size:.9375em;font-style:normal!important;letter-spacing:0;padding:.1em .5ex;word-spacing:-.15em;background-color:#f7f7f8;-webkit-border-radius:4px;border-radius:4px;line-height:1.45;text-rendering:optimizeSpeed;word-wrap:break-word}
 121 *:not(pre)>code.nobreak{word-wrap:normal}
 122 *:not(pre)>code.nowrap{white-space:nowrap}
 123 pre,pre>code{line-height:1.45;color:rgba(0,0,0,.9);font-family:"Droid Sans Mono","DejaVu Sans Mono",monospace;font-weight:400;text-rendering:optimizeSpeed}
 124 em em{font-style:normal}
 125 strong strong{font-weight:400}
 126 .keyseq{color:rgba(51,51,51,.8)}
 127 kbd{font-family:"Droid Sans Mono","DejaVu Sans Mono",monospace;display:inline-block;color:rgba(0,0,0,.8);font-size:.65em;line-height:1.45;background-color:#f7f7f7;border:1px solid #ccc;-webkit-border-radius:3px;border-radius:3px;-webkit-box-shadow:0 1px 0 rgba(0,0,0,.2),0 0 0 .1em white inset;box-shadow:0 1px 0 rgba(0,0,0,.2),0 0 0 .1em #fff inset;margin:0 .15em;padding:.2em .5em;vertical-align:middle;position:relative;top:-.1em;white-space:nowrap}
 128 .keyseq kbd:first-child{margin-left:0}
 129 .keyseq kbd:last-child{margin-right:0}
 130 .menuseq,.menuref{color:#000}
 131 .menuseq b:not(.caret),.menuref{font-weight:inherit}
 132 .menuseq{word-spacing:-.02em}
 133 .menuseq b.caret{font-size:1.25em;line-height:.8}
 134 .menuseq i.caret{font-weight:bold;text-align:center;width:.45em}
 135 b.button::before,b.button::after{position:relative;top:-1px;font-weight:400}
 136 b.button::before{content:"[";padding:0 3px 0 2px}
 137 b.button::after{content:"]";padding:0 2px 0 3px}
 138 p a>code:hover{color:rgba(0,0,0,.9)}
 139 #header,#content,#footnotes,#footer{width:100%;margin-left:auto;margin-right:auto;margin-top:0;margin-bottom:0;max-width:62.5em;*zoom:1;position:relative;padding-left:.9375em;padding-right:.9375em}
 140 #header::before,#header::after,#content::before,#content::after,#footnotes::before,#footnotes::after,#footer::before,#footer::after{content:" ";display:table}
 141 #header::after,#content::after,#footnotes::after,#footer::after{clear:both}
 142 #content{margin-top:1.25em}
 143 #content::before{content:none}
 144 #header>h1:first-child{color:rgba(0,0,0,.85);margin-top:2.25rem;margin-bottom:0}
 145 #header>h1:first-child+#toc{margin-top:8px;border-top:1px solid #dddddf}
 146 #header>h1:only-child,body.toc2 #header>h1:nth-last-child(2){border-bottom:1px solid #dddddf;padding-bottom:8px}
 147 #header .details{border-bottom:1px solid #dddddf;line-height:1.45;padding-top:.25em;padding-bottom:.25em;padding-left:.25em;color:rgba(0,0,0,.6);display:-ms-flexbox;display:-webkit-flex;display:flex;-ms-flex-flow:row wrap;-webkit-flex-flow:row wrap;flex-flow:row wrap}
 148 #header .details span:first-child{margin-left:-.125em}
 149 #header .details span.email a{color:rgba(0,0,0,.85)}
 150 #header .details br{display:none}
 151 #header .details br+span::before{content:"\00a0\2013\00a0"}
 152 #header .details br+span.author::before{content:"\00a0\22c5\00a0";color:rgba(0,0,0,.85)}
 153 #header .details br+span#revremark::before{content:"\00a0|\00a0"}
 154 #header #revnumber{text-transform:capitalize}
 155 #header #revnumber::after{content:"\00a0"}
 156 #content>h1:first-child:not([class]){color:rgba(0,0,0,.85);border-bottom:1px solid #dddddf;padding-bottom:8px;margin-top:0;padding-top:1rem;margin-bottom:1.25rem}
 157 #toc{border-bottom:1px solid #e7e7e9;padding-bottom:.5em}
 158 #toc>ul{margin-left:.125em}
 159 #toc ul.sectlevel0>li>a{font-style:italic}
 160 #toc ul.sectlevel0 ul.sectlevel1{margin:.5em 0}
 161 #toc ul{font-family:"Open Sans","DejaVu Sans",sans-serif;list-style-type:none}
 162 #toc li{line-height:1.3334;margin-top:.3334em}
 163 #toc a{text-decoration:none}
 164 #toc a:active{text-decoration:underline}
 165 #toctitle{color:#7a2518;font-size:1.2em}
 166 @media screen and (min-width:768px){#toctitle{font-size:1.375em}
 167 body.toc2{padding-left:15em;padding-right:0}
 168 #toc.toc2{margin-top:0!important;background-color:#f8f8f7;position:fixed;width:15em;left:0;top:0;border-right:1px solid #e7e7e9;border-top-width:0!important;border-bottom-width:0!important;z-index:1000;padding:1.25em 1em;height:100%;overflow:auto}
 169 #toc.toc2 #toctitle{margin-top:0;margin-bottom:.8rem;font-size:1.2em}
 170 #toc.toc2>ul{font-size:.9em;margin-bottom:0}
 171 #toc.toc2 ul ul{margin-left:0;padding-left:1em}
 172 #toc.toc2 ul.sectlevel0 ul.sectlevel1{padding-left:0;margin-top:.5em;margin-bottom:.5em}
 173 body.toc2.toc-right{padding-left:0;padding-right:15em}
 174 body.toc2.toc-right #toc.toc2{border-right-width:0;border-left:1px solid #e7e7e9;left:auto;right:0}}
 175 @media screen and (min-width:1280px){body.toc2{padding-left:20em;padding-right:0}
 176 #toc.toc2{width:20em}
 177 #toc.toc2 #toctitle{font-size:1.375em}
 178 #toc.toc2>ul{font-size:.95em}
 179 #toc.toc2 ul ul{padding-left:1.25em}
 180 body.toc2.toc-right{padding-left:0;padding-right:20em}}
 181 #content #toc{border-style:solid;border-width:1px;border-color:#e0e0dc;margin-bottom:1.25em;padding:1.25em;background:#f8f8f7;-webkit-border-radius:4px;border-radius:4px}
 182 #content #toc>:first-child{margin-top:0}
 183 #content #toc>:last-child{margin-bottom:0}
 184 #footer{max-width:100%;background-color:rgba(0,0,0,.8);padding:1.25em}
 185 #footer-text{color:rgba(255,255,255,.8);line-height:1.44}
 186 #content{margin-bottom:.625em}
 187 .sect1{padding-bottom:.625em}
 188 @media screen and (min-width:768px){#content{margin-bottom:1.25em}
 189 .sect1{padding-bottom:1.25em}}
 190 .sect1:last-child{padding-bottom:0}
 191 .sect1+.sect1{border-top:1px solid #e7e7e9}
 192 #content h1>a.anchor,h2>a.anchor,h3>a.anchor,#toctitle>a.anchor,.sidebarblock>.content>.title>a.anchor,h4>a.anchor,h5>a.anchor,h6>a.anchor{position:absolute;z-index:1001;width:1.5ex;margin-left:-1.5ex;display:block;text-decoration:none!important;visibility:hidden;text-align:center;font-weight:400}
 193 #content h1>a.anchor::before,h2>a.anchor::before,h3>a.anchor::before,#toctitle>a.anchor::before,.sidebarblock>.content>.title>a.anchor::before,h4>a.anchor::before,h5>a.anchor::before,h6>a.anchor::before{content:"\00A7";font-size:.85em;display:block;padding-top:.1em}
 194 #content h1:hover>a.anchor,#content h1>a.anchor:hover,h2:hover>a.anchor,h2>a.anchor:hover,h3:hover>a.anchor,#toctitle:hover>a.anchor,.sidebarblock>.content>.title:hover>a.anchor,h3>a.anchor:hover,#toctitle>a.anchor:hover,.sidebarblock>.content>.title>a.anchor:hover,h4:hover>a.anchor,h4>a.anchor:hover,h5:hover>a.anchor,h5>a.anchor:hover,h6:hover>a.anchor,h6>a.anchor:hover{visibility:visible}
 195 #content h1>a.link,h2>a.link,h3>a.link,#toctitle>a.link,.sidebarblock>.content>.title>a.link,h4>a.link,h5>a.link,h6>a.link{color:#ba3925;text-decoration:none}
 196 #content h1>a.link:hover,h2>a.link:hover,h3>a.link:hover,#toctitle>a.link:hover,.sidebarblock>.content>.title>a.link:hover,h4>a.link:hover,h5>a.link:hover,h6>a.link:hover{color:#a53221}
 197 .audioblock,.imageblock,.literalblock,.listingblock,.stemblock,.videoblock{margin-bottom:1.25em}
 198 .admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{text-rendering:optimizeLegibility;text-align:left;font-family:"Noto Serif","DejaVu Serif",serif;font-size:1rem;font-style:italic}
 199 table.tableblock.fit-content>caption.title{white-space:nowrap;width:0}
 200 .paragraph.lead>p,#preamble>.sectionbody>[class="paragraph"]:first-of-type p{font-size:1.21875em;line-height:1.6;color:rgba(0,0,0,.85)}
 201 table.tableblock #preamble>.sectionbody>[class="paragraph"]:first-of-type p{font-size:inherit}
 202 .admonitionblock>table{border-collapse:separate;border:0;background:none;width:100%}
 203 .admonitionblock>table td.icon{text-align:center;width:80px}
 204 .admonitionblock>table td.icon img{max-width:none}
 205 .admonitionblock>table td.icon .title{font-weight:bold;font-family:"Open Sans","DejaVu Sans",sans-serif;text-transform:uppercase}
 206 .admonitionblock>table td.content{padding-left:1.125em;padding-right:1.25em;border-left:1px solid #dddddf;color:rgba(0,0,0,.6)}
 207 .admonitionblock>table td.content>:last-child>:last-child{margin-bottom:0}
 208 .exampleblock>.content{border-style:solid;border-width:1px;border-color:#e6e6e6;margin-bottom:1.25em;padding:1.25em;background:#fff;-webkit-border-radius:4px;border-radius:4px}
 209 .exampleblock>.content>:first-child{margin-top:0}
 210 .exampleblock>.content>:last-child{margin-bottom:0}
 211 .sidebarblock{border-style:solid;border-width:1px;border-color:#e0e0dc;margin-bottom:1.25em;padding:1.25em;background:#f8f8f7;-webkit-border-radius:4px;border-radius:4px}
 212 .sidebarblock>:first-child{margin-top:0}
 213 .sidebarblock>:last-child{margin-bottom:0}
 214 .sidebarblock>.content>.title{color:#7a2518;margin-top:0;text-align:center}
 215 .exampleblock>.content>:last-child>:last-child,.exampleblock>.content .olist>ol>li:last-child>:last-child,.exampleblock>.content .ulist>ul>li:last-child>:last-child,.exampleblock>.content .qlist>ol>li:last-child>:last-child,.sidebarblock>.content>:last-child>:last-child,.sidebarblock>.content .olist>ol>li:last-child>:last-child,.sidebarblock>.content .ulist>ul>li:last-child>:last-child,.sidebarblock>.content .qlist>ol>li:last-child>:last-child{margin-bottom:0}
 216 .literalblock pre,.listingblock pre:not(.highlight),.listingblock pre[class="highlight"],.listingblock pre[class^="highlight "],.listingblock pre.CodeRay,.listingblock pre.prettyprint{background:#f7f7f8}
 217 .sidebarblock .literalblock pre,.sidebarblock .listingblock pre:not(.highlight),.sidebarblock .listingblock pre[class="highlight"],.sidebarblock .listingblock pre[class^="highlight "],.sidebarblock .listingblock pre.CodeRay,.sidebarblock .listingblock pre.prettyprint{background:#f2f1f1}
 218 .literalblock pre,.literalblock pre[class],.listingblock pre,.listingblock pre[class]{-webkit-border-radius:4px;border-radius:4px;word-wrap:break-word;overflow-x:auto;padding:1em;font-size:.8125em}
 219 @media screen and (min-width:768px){.literalblock pre,.literalblock pre[class],.listingblock pre,.listingblock pre[class]{font-size:.90625em}}
 220 @media screen and (min-width:1280px){.literalblock pre,.literalblock pre[class],.listingblock pre,.listingblock pre[class]{font-size:1em}}
 221 .literalblock pre.nowrap,.literalblock pre.nowrap pre,.listingblock pre.nowrap,.listingblock pre.nowrap pre{white-space:pre;word-wrap:normal}
 222 .literalblock.output pre{color:#f7f7f8;background-color:rgba(0,0,0,.9)}
 223 .listingblock pre.highlightjs{padding:0}
 224 .listingblock pre.highlightjs>code{padding:1em;-webkit-border-radius:4px;border-radius:4px}
 225 .listingblock pre.prettyprint{border-width:0}
 226 .listingblock>.content{position:relative}
 227 .listingblock code[data-lang]::before{display:none;content:attr(data-lang);position:absolute;font-size:.75em;top:.425rem;right:.5rem;line-height:1;text-transform:uppercase;color:#999}
 228 .listingblock:hover code[data-lang]::before{display:block}
 229 .listingblock.terminal pre .command::before{content:attr(data-prompt);padding-right:.5em;color:#999}
 230 .listingblock.terminal pre .command:not([data-prompt])::before{content:"$"}
 231 table.pyhltable{border-collapse:separate;border:0;margin-bottom:0;background:none}
 232 table.pyhltable td{vertical-align:top;padding-top:0;padding-bottom:0;line-height:1.45}
 233 table.pyhltable td.code{padding-left:.75em;padding-right:0}
 234 pre.pygments .lineno,table.pyhltable td:not(.code){color:#999;padding-left:0;padding-right:.5em;border-right:1px solid #dddddf}
 235 pre.pygments .lineno{display:inline-block;margin-right:.25em}
 236 table.pyhltable .linenodiv{background:none!important;padding-right:0!important}
 237 .quoteblock{margin:0 1em 1.25em 1.5em;display:table}
 238 .quoteblock>.title{margin-left:-1.5em;margin-bottom:.75em}
 239 .quoteblock blockquote,.quoteblock p{color:rgba(0,0,0,.85);font-size:1.15rem;line-height:1.75;word-spacing:.1em;letter-spacing:0;font-style:italic;text-align:justify}
 240 .quoteblock blockquote{margin:0;padding:0;border:0}
 241 .quoteblock blockquote::before{content:"\201c";float:left;font-size:2.75em;font-weight:bold;line-height:.6em;margin-left:-.6em;color:#7a2518;text-shadow:0 1px 2px rgba(0,0,0,.1)}
 242 .quoteblock blockquote>.paragraph:last-child p{margin-bottom:0}
 243 .quoteblock .attribution{margin-top:.75em;margin-right:.5ex;text-align:right}
 244 .verseblock{margin:0 1em 1.25em}
 245 .verseblock pre{font-family:"Open Sans","DejaVu Sans",sans;font-size:1.15rem;color:rgba(0,0,0,.85);font-weight:300;text-rendering:optimizeLegibility}
 246 .verseblock pre strong{font-weight:400}
 247 .verseblock .attribution{margin-top:1.25rem;margin-left:.5ex}
 248 .quoteblock .attribution,.verseblock .attribution{font-size:.9375em;line-height:1.45;font-style:italic}
 249 .quoteblock .attribution br,.verseblock .attribution br{display:none}
 250 .quoteblock .attribution cite,.verseblock .attribution cite{display:block;letter-spacing:-.025em;color:rgba(0,0,0,.6)}
 251 .quoteblock.abstract blockquote::before,.quoteblock.excerpt blockquote::before,.quoteblock .quoteblock blockquote::before{display:none}
 252 .quoteblock.abstract blockquote,.quoteblock.abstract p,.quoteblock.excerpt blockquote,.quoteblock.excerpt p,.quoteblock .quoteblock blockquote,.quoteblock .quoteblock p{line-height:1.6;word-spacing:0}
 253 .quoteblock.abstract{margin:0 1em 1.25em;display:block}
 254 .quoteblock.abstract>.title{margin:0 0 .375em;font-size:1.15em;text-align:center}
 255 .quoteblock.excerpt,.quoteblock .quoteblock{margin:0 0 1.25em;padding:0 0 .25em 1em;border-left:.25em solid #dddddf}
 256 .quoteblock.excerpt blockquote,.quoteblock.excerpt p,.quoteblock .quoteblock blockquote,.quoteblock .quoteblock p{color:inherit;font-size:1.0625rem}
 257 .quoteblock.excerpt .attribution,.quoteblock .quoteblock .attribution{color:inherit;text-align:left;margin-right:0}
 258 table.tableblock{max-width:100%;border-collapse:separate}
 259 p.tableblock:last-child{margin-bottom:0}
 260 td.tableblock>.content{margin-bottom:-1.25em}
 261 table.tableblock,th.tableblock,td.tableblock{border:0 solid #dedede}
 262 table.grid-all>thead>tr>.tableblock,table.grid-all>tbody>tr>.tableblock{border-width:0 1px 1px 0}
 263 table.grid-all>tfoot>tr>.tableblock{border-width:1px 1px 0 0}
 264 table.grid-cols>*>tr>.tableblock{border-width:0 1px 0 0}
 265 table.grid-rows>thead>tr>.tableblock,table.grid-rows>tbody>tr>.tableblock{border-width:0 0 1px}
 266 table.grid-rows>tfoot>tr>.tableblock{border-width:1px 0 0}
 267 table.grid-all>*>tr>.tableblock:last-child,table.grid-cols>*>tr>.tableblock:last-child{border-right-width:0}
 268 table.grid-all>tbody>tr:last-child>.tableblock,table.grid-all>thead:last-child>tr>.tableblock,table.grid-rows>tbody>tr:last-child>.tableblock,table.grid-rows>thead:last-child>tr>.tableblock{border-bottom-width:0}
 269 table.frame-all{border-width:1px}
 270 table.frame-sides{border-width:0 1px}
 271 table.frame-topbot,table.frame-ends{border-width:1px 0}
 272 table.stripes-all tr,table.stripes-odd tr:nth-of-type(odd){background:#f8f8f7}
 273 table.stripes-none tr,table.stripes-odd tr:nth-of-type(even){background:none}
 274 th.halign-left,td.halign-left{text-align:left}
 275 th.halign-right,td.halign-right{text-align:right}
 276 th.halign-center,td.halign-center{text-align:center}
 277 th.valign-top,td.valign-top{vertical-align:top}
 278 th.valign-bottom,td.valign-bottom{vertical-align:bottom}
 279 th.valign-middle,td.valign-middle{vertical-align:middle}
 280 table thead th,table tfoot th{font-weight:bold}
 281 tbody tr th{display:table-cell;line-height:1.6;background:#f7f8f7}
 282 tbody tr th,tbody tr th p,tfoot tr th,tfoot tr th p{color:rgba(0,0,0,.8);font-weight:bold}
 283 p.tableblock>code:only-child{background:none;padding:0}
 284 p.tableblock{font-size:1em}
 285 td>div.verse{white-space:pre}
 286 ol{margin-left:1.75em}
 287 ul li ol{margin-left:1.5em}
 288 dl dd{margin-left:1.125em}
 289 dl dd:last-child,dl dd:last-child>:last-child{margin-bottom:0}
 290 ol>li p,ul>li p,ul dd,ol dd,.olist .olist,.ulist .ulist,.ulist .olist,.olist .ulist{margin-bottom:.625em}
 291 ul.checklist,ul.none,ol.none,ul.no-bullet,ol.no-bullet,ol.unnumbered,ul.unstyled,ol.unstyled{list-style-type:none}
 292 ul.no-bullet,ol.no-bullet,ol.unnumbered{margin-left:.625em}
 293 ul.unstyled,ol.unstyled{margin-left:0}
 294 ul.checklist{margin-left:.625em}
 295 ul.checklist li>p:first-child>.fa-square-o:first-child,ul.checklist li>p:first-child>.fa-check-square-o:first-child{width:1.25em;font-size:.8em;position:relative;bottom:.125em}
 296 ul.checklist li>p:first-child>input[type="checkbox"]:first-child{margin-right:.25em}
 297 ul.inline{display:-ms-flexbox;display:-webkit-box;display:flex;-ms-flex-flow:row wrap;-webkit-flex-flow:row wrap;flex-flow:row wrap;list-style:none;margin:0 0 .625em -1.25em}
 298 ul.inline>li{margin-left:1.25em}
 299 .unstyled dl dt{font-weight:400;font-style:normal}
 300 ol.arabic{list-style-type:decimal}
 301 ol.decimal{list-style-type:decimal-leading-zero}
 302 ol.loweralpha{list-style-type:lower-alpha}
 303 ol.upperalpha{list-style-type:upper-alpha}
 304 ol.lowerroman{list-style-type:lower-roman}
 305 ol.upperroman{list-style-type:upper-roman}
 306 ol.lowergreek{list-style-type:lower-greek}
 307 .hdlist>table,.colist>table{border:0;background:none}
 308 .hdlist>table>tbody>tr,.colist>table>tbody>tr{background:none}
 309 td.hdlist1,td.hdlist2{vertical-align:top;padding:0 .625em}
 310 td.hdlist1{font-weight:bold;padding-bottom:1.25em}
 311 .literalblock+.colist,.listingblock+.colist{margin-top:-.5em}
 312 .colist td:not([class]):first-child{padding:.4em .75em 0;line-height:1;vertical-align:top}
 313 .colist td:not([class]):first-child img{max-width:none}
 314 .colist td:not([class]):last-child{padding:.25em 0}
 315 .thumb,.th{line-height:0;display:inline-block;border:solid 4px #fff;-webkit-box-shadow:0 0 0 1px #ddd;box-shadow:0 0 0 1px #ddd}
 316 .imageblock.left{margin:.25em .625em 1.25em 0}
 317 .imageblock.right{margin:.25em 0 1.25em .625em}
 318 .imageblock>.title{margin-bottom:0}
 319 .imageblock.thumb,.imageblock.th{border-width:6px}
 320 .imageblock.thumb>.title,.imageblock.th>.title{padding:0 .125em}
 321 .image.left,.image.right{margin-top:.25em;margin-bottom:.25em;display:inline-block;line-height:0}
 322 .image.left{margin-right:.625em}
 323 .image.right{margin-left:.625em}
 324 a.image{text-decoration:none;display:inline-block}
 325 a.image object{pointer-events:none}
 326 sup.footnote,sup.footnoteref{font-size:.875em;position:static;vertical-align:super}
 327 sup.footnote a,sup.footnoteref a{text-decoration:none}
 328 sup.footnote a:active,sup.footnoteref a:active{text-decoration:underline}
 329 #footnotes{padding-top:.75em;padding-bottom:.75em;margin-bottom:.625em}
 330 #footnotes hr{width:20%;min-width:6.25em;margin:-.25em 0 .75em;border-width:1px 0 0}
 331 #footnotes .footnote{padding:0 .375em 0 .225em;line-height:1.3334;font-size:.875em;margin-left:1.2em;margin-bottom:.2em}
 332 #footnotes .footnote a:first-of-type{font-weight:bold;text-decoration:none;margin-left:-1.05em}
 333 #footnotes .footnote:last-of-type{margin-bottom:0}
 334 #content #footnotes{margin-top:-.625em;margin-bottom:0;padding:.75em 0}
 335 .gist .file-data>table{border:0;background:#fff;width:100%;margin-bottom:0}
 336 .gist .file-data>table td.line-data{width:99%}
 337 div.unbreakable{page-break-inside:avoid}
 338 .big{font-size:larger}
 339 .small{font-size:smaller}
 340 .underline{text-decoration:underline}
 341 .overline{text-decoration:overline}
 342 .line-through{text-decoration:line-through}
 343 .aqua{color:#00bfbf}
 344 .aqua-background{background-color:#00fafa}
 345 .black{color:#000}
 346 .black-background{background-color:#000}
 347 .blue{color:#0000bf}
 348 .blue-background{background-color:#0000fa}
 349 .fuchsia{color:#bf00bf}
 350 .fuchsia-background{background-color:#fa00fa}
 351 .gray{color:#606060}
 352 .gray-background{background-color:#7d7d7d}
 353 .green{color:#006000}
 354 .green-background{background-color:#007d00}
 355 .lime{color:#00bf00}
 356 .lime-background{background-color:#00fa00}
 357 .maroon{color:#600000}
 358 .maroon-background{background-color:#7d0000}
 359 .navy{color:#000060}
 360 .navy-background{background-color:#00007d}
 361 .olive{color:#606000}
 362 .olive-background{background-color:#7d7d00}
 363 .purple{color:#600060}
 364 .purple-background{background-color:#7d007d}
 365 .red{color:#bf0000}
 366 .red-background{background-color:#fa0000}
 367 .silver{color:#909090}
 368 .silver-background{background-color:#bcbcbc}
 369 .teal{color:#006060}
 370 .teal-background{background-color:#007d7d}
 371 .white{color:#bfbfbf}
 372 .white-background{background-color:#fafafa}
 373 .yellow{color:#bfbf00}
 374 .yellow-background{background-color:#fafa00}
 375 span.icon>.fa{cursor:default}
 376 a span.icon>.fa{cursor:inherit}
 377 .admonitionblock td.icon [class^="fa icon-"]{font-size:2.5em;text-shadow:1px 1px 2px rgba(0,0,0,.5);cursor:default}
 378 .admonitionblock td.icon .icon-note::before{content:"\f05a";color:#19407c}
 379 .admonitionblock td.icon .icon-tip::before{content:"\f0eb";text-shadow:1px 1px 2px rgba(155,155,0,.8);color:#111}
 380 .admonitionblock td.icon .icon-warning::before{content:"\f071";color:#bf6900}
 381 .admonitionblock td.icon .icon-caution::before{content:"\f06d";color:#bf3400}
 382 .admonitionblock td.icon .icon-important::before{content:"\f06a";color:#bf0000}
 383 .conum[data-value]{display:inline-block;color:#fff!important;background-color:rgba(0,0,0,.8);-webkit-border-radius:100px;border-radius:100px;text-align:center;font-size:.75em;width:1.67em;height:1.67em;line-height:1.67em;font-family:"Open Sans","DejaVu Sans",sans-serif;font-style:normal;font-weight:bold}
 384 .conum[data-value] *{color:#fff!important}
 385 .conum[data-value]+b{display:none}
 386 .conum[data-value]::after{content:attr(data-value)}
 387 pre .conum[data-value]{position:relative;top:-.125em}
 388 b.conum *{color:inherit!important}
 389 .conum:not([data-value]):empty{display:none}
 390 dt,th.tableblock,td.content,div.footnote{text-rendering:optimizeLegibility}
 391 h1,h2,p,td.content,span.alt{letter-spacing:-.01em}
 392 p strong,td.content strong,div.footnote strong{letter-spacing:-.005em}
 393 p,blockquote,dt,td.content,span.alt{font-size:1.0625rem}
 394 p{margin-bottom:1.25rem}
 395 .sidebarblock p,.sidebarblock dt,.sidebarblock td.content,p.tableblock{font-size:1em}
 396 .exampleblock>.content{background-color:#fffef7;border-color:#e0e0dc;-webkit-box-shadow:0 1px 4px #e0e0dc;box-shadow:0 1px 4px #e0e0dc}
 397 .print-only{display:none!important}
 398 @page{margin:1.25cm .75cm}
 399 @media print{*{-webkit-box-shadow:none!important;box-shadow:none!important;text-shadow:none!important}
 400 html{font-size:80%}
 401 a{color:inherit!important;text-decoration:underline!important}
 402 a.bare,a[href^="#"],a[href^="mailto:"]{text-decoration:none!important}
 403 a[href^="http:"]:not(.bare)::after,a[href^="https:"]:not(.bare)::after{content:"(" attr(href) ")";display:inline-block;font-size:.875em;padding-left:.25em}
 404 abbr[title]::after{content:" (" attr(title) ")"}
 405 pre,blockquote,tr,img,object,svg{page-break-inside:avoid}
 406 thead{display:table-header-group}
 407 svg{max-width:100%}
 408 p,blockquote,dt,td.content{font-size:1em;orphans:3;widows:3}
 409 h2,h3,#toctitle,.sidebarblock>.content>.title{page-break-after:avoid}
 410 #toc,.sidebarblock,.exampleblock>.content{background:none!important}
 411 #toc{border-bottom:1px solid #dddddf!important;padding-bottom:0!important}
 412 body.book #header{text-align:center}
 413 body.book #header>h1:first-child{border:0!important;margin:2.5em 0 1em}
 414 body.book #header .details{border:0!important;display:block;padding:0!important}
 415 body.book #header .details span:first-child{margin-left:0!important}
 416 body.book #header .details br{display:block}
 417 body.book #header .details br+span::before{content:none!important}
 418 body.book #toc{border:0!important;text-align:left!important;padding:0!important;margin:0!important}
 419 body.book #toc,body.book #preamble,body.book h1.sect0,body.book .sect1>h2{page-break-before:always}
 420 .listingblock code[data-lang]::before{display:block}
 421 #footer{padding:0 .9375em}
 422 .hide-on-print{display:none!important}
 423 .print-only{display:block!important}
 424 .hide-for-print{display:none!important}
 425 .show-for-print{display:inherit!important}}
 426 @media print,amzn-kf8{#header>h1:first-child{margin-top:1.25rem}
 427 .sect1{padding:0!important}
 428 .sect1+.sect1{border:0}
 429 #footer{background:none}
 430 #footer-text{color:rgba(0,0,0,.6);font-size:.9em}}
 431 @media amzn-kf8{#header,#content,#footnotes,#footer{padding:0}}
 432 </style>
 433 </head>
 434 <body class="article toc2 toc-left">
 435 <div id="header">
 436 <h1>Boost.SmartPtr: The Smart Pointer Library</h1>
 437 <div class="details">
 438 <span id="author" class="author">Greg Colvin, Beman Dawes, Peter Dimov, Glen Fernandes</span><br>
 439 </div>
 440 <div id="toc" class="toc2">
 441 <div id="toctitle">Table of Contents</div>
 442 <ul class="sectlevel1">
 443 <li><a href="#introduction">Introduction</a></li>
 444 <li><a href="#changelog">Revision History</a>
 445 <ul class="sectlevel2">
 446 <li><a href="#changelog_changes_in_1_72_0">Changes in 1.72.0</a></li>
 447 <li><a href="#changelog_changes_in_1_71_0">Changes in 1.71.0</a></li>
 448 <li><a href="#changelog_changes_in_1_65_0">Changes in 1.65.0</a></li>
 449 </ul>
 450 </li>
 451 <li><a href="#scoped_ptr">scoped_ptr: Scoped Object Ownership</a>
 452 <ul class="sectlevel2">
 453 <li><a href="#scoped_ptr_description">Description</a></li>
 454 <li><a href="#scoped_ptr_synopsis">Synopsis</a></li>
 455 <li><a href="#scoped_ptr_members">Members</a></li>
 456 <li><a href="#scoped_ptr_free_functions">Free Functions</a></li>
 457 <li><a href="#scoped_ptr_example">Example</a></li>
 458 <li><a href="#scoped_ptr_rationale">Rationale</a></li>
 459 <li><a href="#scoped_ptr_handlebody_idiom">Handle/Body Idiom</a></li>
 460 <li><a href="#scoped_ptr_frequently_asked_questions">Frequently Asked Questions</a></li>
 461 </ul>
 462 </li>
 463 <li><a href="#scoped_array">scoped_array: Scoped Array Ownership</a>
 464 <ul class="sectlevel2">
 465 <li><a href="#scoped_array_description">Description</a></li>
 466 <li><a href="#scoped_array_synopsis">Synopsis</a></li>
 467 <li><a href="#scoped_array_members">Members</a></li>
 468 <li><a href="#scoped_array_free_functions">Free Functions</a></li>
 469 </ul>
 470 </li>
 471 <li><a href="#shared_ptr">shared_ptr: Shared Ownership</a>
 472 <ul class="sectlevel2">
 473 <li><a href="#shared_ptr_description">Description</a></li>
 474 <li><a href="#shared_ptr_best_practices">Best Practices</a></li>
 475 <li><a href="#shared_ptr_synopsis">Synopsis</a></li>
 476 <li><a href="#shared_ptr_members">Members</a></li>
 477 <li><a href="#shared_ptr_free_functions">Free Functions</a></li>
 478 <li><a href="#shared_ptr_example">Example</a></li>
 479 <li><a href="#shared_ptr_handlebody_idiom">Handle/Body Idiom</a></li>
 480 <li><a href="#shared_ptr_thread_safety">Thread Safety</a></li>
 481 <li><a href="#shared_ptr_frequently_asked_questions">Frequently Asked Questions</a></li>
 482 </ul>
 483 </li>
 484 <li><a href="#weak_ptr">weak_ptr: Non-owning Observer</a>
 485 <ul class="sectlevel2">
 486 <li><a href="#weak_ptr_description">Description</a></li>
 487 <li><a href="#weak_ptr_synopsis">Synopsis</a></li>
 488 <li><a href="#weak_ptr_members">Members</a></li>
 489 <li><a href="#weak_ptr_free_functions">Free Functions</a></li>
 490 <li><a href="#weak_ptr_frequently_asked_questions">Frequently Asked Questions</a></li>
 491 </ul>
 492 </li>
 493 <li><a href="#make_shared">make_shared: Creating shared_ptr</a>
 494 <ul class="sectlevel2">
 495 <li><a href="#make_shared_description">Description</a></li>
 496 <li><a href="#make_shared_rationale">Rationale</a></li>
 497 <li><a href="#make_shared_synopsis">Synopsis</a></li>
 498 <li><a href="#make_shared_common_requirements">Common Requirements</a></li>
 499 <li><a href="#make_shared_free_functions">Free Functions</a></li>
 500 </ul>
 501 </li>
 502 <li><a href="#enable_shared_from_this">enable_shared_from_this</a>
 503 <ul class="sectlevel2">
 504 <li><a href="#enable_shared_from_this_description">Description</a></li>
 505 <li><a href="#enable_shared_from_this_example">Example</a></li>
 506 <li><a href="#enable_shared_from_this_synopsis">Synopsis</a></li>
 507 <li><a href="#enable_shared_from_this_members">Members</a></li>
 508 </ul>
 509 </li>
 510 <li><a href="#enable_shared_from">enable_shared_from</a>
 511 <ul class="sectlevel2">
 512 <li><a href="#enable_shared_from_description">Description</a></li>
 513 <li><a href="#enable_shared_from_example">Example</a></li>
 514 <li><a href="#enable_shared_from_synopsis">Synopsis</a></li>
 515 <li><a href="#enable_shared_from_functions">Functions</a></li>
 516 </ul>
 517 </li>
 518 <li><a href="#make_unique">make_unique: Creating unique_ptr</a>
 519 <ul class="sectlevel2">
 520 <li><a href="#make_unique_description">Description</a></li>
 521 <li><a href="#make_unique_rationale">Rationale</a></li>
 522 <li><a href="#make_unique_synopsis">Synopsis</a></li>
 523 <li><a href="#make_unique_free_functions">Free Functions</a></li>
 524 </ul>
 525 </li>
 526 <li><a href="#allocate_unique">allocate_unique: Creating unique_ptr</a>
 527 <ul class="sectlevel2">
 528 <li><a href="#allocate_unique_description">Description</a></li>
 529 <li><a href="#allocate_unique_rationale">Rationale</a></li>
 530 <li><a href="#allocate_unique_synopsis">Synopsis</a></li>
 531 <li><a href="#allocate_unique_common_requirements">Common Requirements</a></li>
 532 <li><a href="#allocate_unique_free_functions">Free Functions</a></li>
 533 <li><a href="#allocate_unique_deleter">Deleter</a></li>
 534 </ul>
 535 </li>
 536 <li><a href="#intrusive_ptr">intrusive_ptr: Managing Objects with Embedded Counts</a>
 537 <ul class="sectlevel2">
 538 <li><a href="#intrusive_ptr_description">Description</a></li>
 539 <li><a href="#intrusive_ptr_synopsis">Synopsis</a></li>
 540 <li><a href="#intrusive_ptr_members">Members</a></li>
 541 <li><a href="#intrusive_ptr_free_functions">Free Functions</a></li>
 542 </ul>
 543 </li>
 544 <li><a href="#intrusive_ref_counter">intrusive_ref_counter</a>
 545 <ul class="sectlevel2">
 546 <li><a href="#intrusive_ref_counter_description">Description</a></li>
 547 <li><a href="#intrusive_ref_counter_synopsis">Synopsis</a></li>
 548 <li><a href="#intrusive_ref_counter_members">Members</a></li>
 549 <li><a href="#intrusive_ref_counter_free_functions">Free Functions</a></li>
 550 </ul>
 551 </li>
 552 <li><a href="#local_shared_ptr">local_shared_ptr: Shared Ownership within a Single Thread</a>
 553 <ul class="sectlevel2">
 554 <li><a href="#local_shared_ptr_description">Description</a></li>
 555 <li><a href="#local_shared_ptr_synopsis">Synopsis</a></li>
 556 <li><a href="#local_shared_ptr_members">Members</a></li>
 557 <li><a href="#local_shared_ptr_free_functions">Free Functions</a></li>
 558 </ul>
 559 </li>
 560 <li><a href="#make_local_shared">make_local_shared: Creating local_shared_ptr</a>
 561 <ul class="sectlevel2">
 562 <li><a href="#make_local_shared_description">Description</a></li>
 563 <li><a href="#make_local_shared_synopsis">Synopsis</a></li>
 564 <li><a href="#make_local_shared_description_2">Description</a></li>
 565 </ul>
 566 </li>
 567 <li><a href="#pointer_cast">Generic Pointer Casts</a>
 568 <ul class="sectlevel2">
 569 <li><a href="#pointer_cast_description">Description</a></li>
 570 <li><a href="#pointer_cast_rationale">Rationale</a></li>
 571 <li><a href="#pointer_cast_synopsis">Synopsis</a></li>
 572 <li><a href="#pointer_cast_free_functions">Free Functions</a></li>
 573 <li><a href="#pointer_cast_example">Example</a></li>
 574 </ul>
 575 </li>
 576 <li><a href="#pointer_to_other">pointer_to_other</a>
 577 <ul class="sectlevel2">
 578 <li><a href="#pointer_to_other_description">Description</a></li>
 579 <li><a href="#pointer_to_other_rationale">Rationale</a></li>
 580 <li><a href="#pointer_to_other_synopsis">Synopsis</a></li>
 581 <li><a href="#pointer_to_other_example">Example</a></li>
 582 </ul>
 583 </li>
 584 <li><a href="#atomic_shared_ptr">atomic_shared_ptr</a>
 585 <ul class="sectlevel2">
 586 <li><a href="#atomic_shared_ptr_description">Description</a></li>
 587 <li><a href="#atomic_shared_ptr_synopsis">Synopsis</a></li>
 588 <li><a href="#atomic_shared_ptr_members">Members</a></li>
 589 </ul>
 590 </li>
 591 <li><a href="#techniques">Appendix A: Smart Pointer Programming Techniques</a>
 592 <ul class="sectlevel2">
 593 <li><a href="#techniques_incomplete">Using incomplete classes for implementation hiding</a></li>
 594 <li><a href="#techniques_the_pimpl_idiom">The "Pimpl" idiom</a></li>
 595 <li><a href="#techniques_using_abstract_classes_for_implementation_hiding">Using abstract classes for implementation hiding</a></li>
 596 <li><a href="#techniques_preventing_delete_px_get">Preventing <code>delete px.get()</code></a></li>
 597 <li><a href="#techniques_encapsulating_allocation_details_wrapping_factory_functions">Encapsulating allocation details, wrapping factory functions</a></li>
 598 <li><a href="#techniques_static">Using a shared_ptr to hold a pointer to a statically allocated object</a></li>
 599 <li><a href="#techniques_using_a_shared_ptr_to_hold_a_pointer_to_a_com_object">Using a shared_ptr to hold a pointer to a COM Object</a></li>
 600 <li><a href="#techniques_intrusive">Using a shared_ptr to hold a pointer to an object with an embedded reference count</a></li>
 601 <li><a href="#techniques_using_a_shared_ptr_to_hold_another_shared_ownership_smart_pointer">Using a shared_ptr to hold another shared ownership smart pointer</a></li>
 602 <li><a href="#techniques_from_raw">Obtaining a shared_ptr from a raw pointer</a></li>
 603 <li><a href="#techniques_obtaining_a_shared_ptr_weak_ptr_to_this_in_a_constructor">Obtaining a shared_ptr (weak_ptr) to this in a constructor</a></li>
 604 <li><a href="#techniques_obtaining_a_shared_ptr_to_this">Obtaining a shared_ptr to this</a></li>
 605 <li><a href="#techniques_using_shared_ptr_as_a_smart_counted_handle">Using shared_ptr as a smart counted handle</a></li>
 606 <li><a href="#techniques_using_shared_ptr_to_execute_code_on_block_exit">Using shared_ptr to execute code on block exit</a></li>
 607 <li><a href="#techniques_using_shared_ptrvoid_to_hold_an_arbitrary_object">Using shared_ptr&lt;void&gt; to hold an arbitrary object</a></li>
 608 <li><a href="#techniques_associating_arbitrary_data_with_heterogeneous_shared_ptr_instances">Associating arbitrary data with heterogeneous <code>shared_ptr</code> instances</a></li>
 609 <li><a href="#techniques_using_shared_ptr_as_a_copyconstructible_mutex_lock">Using <code>shared_ptr</code> as a <code>CopyConstructible</code> mutex lock</a></li>
 610 <li><a href="#techniques_using_shared_ptr_to_wrap_member_function_calls">Using shared_ptr to wrap member function calls</a></li>
 611 <li><a href="#techniques_delayed_deallocation">Delayed deallocation</a></li>
 612 <li><a href="#techniques_weak_without_shared">Weak pointers to objects not managed by a shared_ptr</a></li>
 613 </ul>
 614 </li>
 615 <li><a href="#history">Appendix B: History and Acknowledgments</a>
 616 <ul class="sectlevel2">
 617 <li><a href="#history_summer_1994">Summer 1994</a></li>
 618 <li><a href="#history_october_1998">October 1998</a></li>
 619 <li><a href="#history_may_1999">May 1999</a></li>
 620 <li><a href="#history_september_1999">September 1999</a></li>
 621 <li><a href="#history_november_1999">November 1999</a></li>
 622 <li><a href="#history_may_2001">May 2001</a></li>
 623 <li><a href="#history_january_2002">January 2002</a></li>
 624 <li><a href="#history_march_2003">March 2003</a></li>
 625 <li><a href="#history_july_2007">July 2007</a></li>
 626 <li><a href="#history_november_2012">November 2012</a></li>
 627 <li><a href="#history_april_2013">April 2013</a></li>
 628 <li><a href="#history_february_2014">February 2014</a></li>
 629 <li><a href="#history_february_2017">February 2017</a></li>
 630 <li><a href="#history_june_2017">June 2017</a></li>
 631 <li><a href="#history_august_2019">August 2019</a></li>
 632 </ul>
 633 </li>
 634 <li><a href="#shared_array">Appendix C: shared_array (deprecated)</a>
 635 <ul class="sectlevel2">
 636 <li><a href="#shared_array_description">Description</a></li>
 637 <li><a href="#shared_array_synopsis">Synopsis</a></li>
 638 <li><a href="#shared_array_members">Members</a></li>
 639 <li><a href="#shared_array_free_functions">Free Functions</a></li>
 640 </ul>
 641 </li>
 642 <li><a href="#copyright">Appendix D: Copyright and License</a></li>
 643 </ul>
 644 </div>
 645 </div>
 646 <div id="content">
 647 <div class="sect1">
 648 <h2 id="introduction">Introduction</h2>
 649 <div class="sectionbody">
 650 <div class="paragraph">
 651 <p>Smart pointers are objects which store pointers to dynamically allocated (heap) objects.
 652 They behave much like built-in C&#43;&#43; pointers except that they automatically delete the object
 653 pointed to at the appropriate time. Smart pointers are particularly useful in the face of
 654 exceptions as they ensure proper destruction of dynamically allocated objects. They can also be
 655 used to keep track of dynamically allocated objects shared by multiple owners.</p>
 656 </div>
 657 <div class="paragraph">
 658 <p>Conceptually, smart pointers are seen as owning the object pointed to, and thus responsible for
 659 deletion of the object when it is no longer needed. As such, they are examples of the "resource
 660 acquisition is initialization" idiom described in Bjarne Stroustrup&#8217;s "The C++ Programming Language",
 661 3rd edition, Section 14.4, Resource Management.</p>
 662 </div>
 663 <div class="paragraph">
 664 <p>This library provides six smart pointer class templates:</p>
 665 </div>
 666 <div class="ulist">
 667 <ul>
 668 <li>
 669 <p><code><a href="#scoped_ptr">scoped_ptr</a></code>, used to contain ownership of a dynamically allocated object to the current scope;</p>
 670 </li>
 671 <li>
 672 <p><code><a href="#scoped_array">scoped_array</a></code>, which provides scoped ownership for a dynamically allocated array;</p>
 673 </li>
 674 <li>
 675 <p><code><a href="#shared_ptr">shared_ptr</a></code>, a versatile tool for managing shared ownership of an object or array;</p>
 676 </li>
 677 <li>
 678 <p><code><a href="#weak_ptr">weak_ptr</a></code>, a non-owning observer to a shared_ptr-managed object that can be promoted temporarily to shared_ptr;</p>
 679 </li>
 680 <li>
 681 <p><code><a href="#intrusive_ptr">intrusive_ptr</a></code>, a pointer to objects with an embedded reference count;</p>
 682 </li>
 683 <li>
 684 <p><code><a href="#local_shared_ptr">local_shared_ptr</a></code>, providing shared ownership within a single thread.</p>
 685 </li>
 686 </ul>
 687 </div>
 688 <div class="paragraph">
 689 <p><code>shared_ptr</code> and <code>weak_ptr</code> are part of the C&#43;&#43; standard since its 2011 iteration.</p>
 690 </div>
 691 <div class="paragraph">
 692 <p>In addition, the library contains the following supporting utility functions and classes:</p>
 693 </div>
 694 <div class="ulist">
 695 <ul>
 696 <li>
 697 <p><code><a href="#make_shared">make_shared</a></code>, a factory function for creating objects that returns a <code>shared_ptr</code>;</p>
 698 </li>
 699 <li>
 700 <p><code><a href="#make_unique">make_unique</a></code>, a factory function returning <code>std::unique_ptr</code>;</p>
 701 </li>
 702 <li>
 703 <p><code><a href="#allocate_unique">allocate_unique</a></code>, a factory function for creating objects using an allocator that returns a <code>std::unique_ptr</code>;</p>
 704 </li>
 705 <li>
 706 <p><code><a href="#enable_shared_from_this">enable_shared_from_this</a></code>, a helper base class that enables the acquisition of a <code>shared_ptr</code> pointing to <code>this</code>;</p>
 707 </li>
 708 <li>
 709 <p><code><a href="#pointer_to_other">pointer_to_other</a></code>, a helper trait for converting one smart pointer type to another;</p>
 710 </li>
 711 <li>
 712 <p><code><a href="#pointer_cast">static_pointer_cast</a></code> and companions, generic smart pointer casts;</p>
 713 </li>
 714 <li>
 715 <p><code><a href="#intrusive_ref_counter">intrusive_ref_counter</a></code>, a helper base class containing a reference count.</p>
 716 </li>
 717 <li>
 718 <p><code><a href="#atomic_shared_ptr">atomic_shared_ptr</a></code>, a helper class implementing the interface of <code>std::atomic</code> for a value of type <code>shared_ptr</code>.</p>
 719 </li>
 720 </ul>
 721 </div>
 722 <div class="paragraph">
 723 <p>As a general rule, the destructor or <code>operator delete</code> for an object managed by pointers in the library
 724 are not allowed to throw exceptions.</p>
 725 </div>
 726 </div>
 727 </div>
 728 <div class="sect1">
 729 <h2 id="changelog">Revision History</h2>
 730 <div class="sectionbody">
 731 <div class="sect2">
 732 <h3 id="changelog_changes_in_1_72_0">Changes in 1.72.0</h3>
 733 <div class="ulist">
 734 <ul>
 735 <li>
 736 <p>Added <code>allocate_unique</code></p>
 737 </li>
 738 </ul>
 739 </div>
 740 </div>
 741 <div class="sect2">
 742 <h3 id="changelog_changes_in_1_71_0">Changes in 1.71.0</h3>
 743 <div class="ulist">
 744 <ul>
 745 <li>
 746 <p>Added aliasing constructors to <code>weak_ptr</code></p>
 747 </li>
 748 <li>
 749 <p>Added <code>weak_ptr&lt;T&gt;::empty()</code></p>
 750 </li>
 751 <li>
 752 <p>Added <code>enable_shared_from</code>, <code>shared_from</code>, and <code>weak_from</code></p>
 753 </li>
 754 </ul>
 755 </div>
 756 </div>
 757 <div class="sect2">
 758 <h3 id="changelog_changes_in_1_65_0">Changes in 1.65.0</h3>
 759 <div class="ulist">
 760 <ul>
 761 <li>
 762 <p>Added <code>atomic_shared_ptr</code></p>
 763 </li>
 764 <li>
 765 <p>Added <code>local_shared_ptr</code>, <code>make_local_shared</code></p>
 766 </li>
 767 </ul>
 768 </div>
 769 </div>
 770 </div>
 771 </div>
 772 <div class="sect1">
 773 <h2 id="scoped_ptr">scoped_ptr: Scoped Object Ownership</h2>
 774 <div class="sectionbody">
 775 <div class="sect2">
 776 <h3 id="scoped_ptr_description">Description</h3>
 777 <div class="paragraph">
 778 <p>The <code>scoped_ptr</code> class template stores a pointer to a dynamically allocated object.
 779 (Dynamically allocated objects are allocated with the C&#43;&#43; <code>new</code> expression.) The
 780 object pointed to is guaranteed to be deleted, either on destruction of the <code>scoped_ptr</code>,
 781 or via an explicit <code>reset</code>. See the <a href="#scoped_ptr_example">example</a>.</p>
 782 </div>
 783 <div class="paragraph">
 784 <p><code>scoped_ptr</code> is a simple solution for simple needs. It supplies a basic "resource acquisition
 785 is initialization" facility, without shared-ownership or transfer-of-ownership semantics.
 786 Both its name and enforcement of semantics (by being  noncopyable) signal its intent to retain
 787 ownership solely within the current scope. Because it is noncopyable, it is safer than <code>shared_ptr</code>
 788 for pointers which should not be copied.</p>
 789 </div>
 790 <div class="paragraph">
 791 <p>Because <code>scoped_ptr</code> is simple, in its usual implementation every operation is as fast as for a
 792 built-in pointer and it has no more space overhead that a built-in pointer.</p>
 793 </div>
 794 <div class="paragraph">
 795 <p><code>scoped_ptr</code> cannot be used in C&#43;&#43; Standard Library containers. Use <code>shared_ptr</code> or <code>std::unique_ptr</code>
 796 if you need a smart pointer that can.</p>
 797 </div>
 798 <div class="paragraph">
 799 <p><code>scoped_ptr</code> cannot correctly hold a pointer to a dynamically allocated array. See <code>scoped_array</code> for that usage.</p>
 800 </div>
 801 <div class="paragraph">
 802 <p>The class template is parameterized on <code>T</code>, the type of the object pointed to. Destroying <code>T</code> must not thow exceptions,
 803 and <code>T</code> must be complete at the point <code>scoped_ptr&lt;T&gt;::~scoped_ptr</code> is instantiated.</p>
 804 </div>
 805 </div>
 806 <div class="sect2">
 807 <h3 id="scoped_ptr_synopsis">Synopsis</h3>
 808 <div class="paragraph">
 809 <p><code>scoped_ptr</code> is defined in <code>&lt;boost/smart_ptr/scoped_ptr.hpp&gt;</code>.</p>
 810 </div>
 811 <div class="listingblock">
 812 <div class="content">
 813 <pre class="highlight"><code>namespace boost {
 814
 815   template&lt;class T&gt; class scoped_ptr {
 816   private:
 817
 818     scoped_ptr(scoped_ptr const&amp;);
 819     scoped_ptr&amp; operator=(scoped_ptr const&amp;);
 820
 821     void operator==(scoped_ptr const&amp;) const;
 822     void operator!=(scoped_ptr const&amp;) const;
 823
 824   public:
 825
 826     typedef T element_type;
 827
 828     explicit scoped_ptr(T * p = 0) noexcept;
 829     ~scoped_ptr() noexcept;
 830
 831     void reset(T * p = 0) noexcept;
 832
 833     T &amp; operator*() const noexcept;
 834     T * operator-&gt;() const noexcept;
 835     T * get() const noexcept;
 836
 837     explicit operator bool() const noexcept;
 838
 839     void swap(scoped_ptr &amp; b) noexcept;
 840   };
 841
 842   template&lt;class T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b) noexcept;
 843
 844   template&lt;class T&gt;
 845     bool operator==( scoped_ptr&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;
 846   template&lt;class T&gt;
 847     bool operator==( std::nullptr_t, scoped_ptr&lt;T&gt; const &amp; p ) noexcept;
 848
 849   template&lt;class T&gt;
 850     bool operator!=( scoped_ptr&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;
 851   template&lt;class T&gt;
 852     bool operator!=( std::nullptr_t, scoped_ptr&lt;T&gt; const &amp; p ) noexcept;
 853 }</code></pre>
 854 </div>
 855 </div>
 856 </div>
 857 <div class="sect2">
 858 <h3 id="scoped_ptr_members">Members</h3>
 859 <div class="sect3">
 860 <h4 id="scoped_ptr_element_type">element_type</h4>
 861 <div class="literalblock">
 862 <div class="content">
 863 <pre>typedef T element_type;</pre>
 864 </div>
 865 </div>
 866 <div class="paragraph">
 867 <p>Provides the type of the stored pointer.</p>
 868 </div>
 869 </div>
 870 <div class="sect3">
 871 <h4 id="scoped_ptr_constructor">constructor</h4>
 872 <div class="literalblock">
 873 <div class="content">
 874 <pre>explicit scoped_ptr(T * p = 0) noexcept;</pre>
 875 </div>
 876 </div>
 877 <div class="paragraph">
 878 <p>Constructs a <code>scoped_ptr</code>, storing a copy of <code>p</code>, which must have been allocated via a
 879 C&#43;&#43; <code>new</code> expression or be 0. <code>T</code> is not required be a complete type.</p>
 880 </div>
 881 </div>
 882 <div class="sect3">
 883 <h4 id="scoped_ptr_destructor">destructor</h4>
 884 <div class="literalblock">
 885 <div class="content">
 886 <pre>~scoped_ptr() noexcept;</pre>
 887 </div>
 888 </div>
 889 <div class="paragraph">
 890 <p>Destroys the object pointed to by the stored pointer, if any, as if by using
 891 <code>delete this-&gt;get()</code>. <code>T</code> must be a complete type.</p>
 892 </div>
 893 </div>
 894 <div class="sect3">
 895 <h4 id="scoped_ptr_reset">reset</h4>
 896 <div class="literalblock">
 897 <div class="content">
 898 <pre>void reset(T * p = 0) noexcept;</pre>
 899 </div>
 900 </div>
 901 <div class="paragraph">
 902 <p>Deletes the object pointed to by the stored pointer and then stores a copy of
 903 <code>p</code>, which must have been allocated via a C&#43;&#43; <code>new</code> expression or be 0.</p>
 904 </div>
 905 <div class="paragraph">
 906 <p>Since the previous object needs to be deleted, <code>T</code> must be a complete type.</p>
 907 </div>
 908 </div>
 909 <div class="sect3">
 910 <h4 id="scoped_ptr_indirection">indirection</h4>
 911 <div class="literalblock">
 912 <div class="content">
 913 <pre>T &amp; operator*() const noexcept;</pre>
 914 </div>
 915 </div>
 916 <div class="paragraph">
 917 <p>Returns a reference to the object pointed to by the stored pointer. Behavior is undefined if the stored pointer is 0.</p>
 918 </div>
 919 <div class="literalblock">
 920 <div class="content">
 921 <pre>T * operator-&gt;() const noexcept;</pre>
 922 </div>
 923 </div>
 924 <div class="paragraph">
 925 <p>Returns the stored pointer. Behavior is undefined if the stored pointer is 0.</p>
 926 </div>
 927 </div>
 928 <div class="sect3">
 929 <h4 id="scoped_ptr_get">get</h4>
 930 <div class="literalblock">
 931 <div class="content">
 932 <pre>T * get() const noexcept;</pre>
 933 </div>
 934 </div>
 935 <div class="paragraph">
 936 <p>Returns the stored pointer. <code>T</code> need not be a complete type.</p>
 937 </div>
 938 </div>
 939 <div class="sect3">
 940 <h4 id="scoped_ptr_conversions">conversions</h4>
 941 <div class="literalblock">
 942 <div class="content">
 943 <pre>explicit operator bool () const noexcept; // never throws</pre>
 944 </div>
 945 </div>
 946 <div class="paragraph">
 947 <p>Returns <code>get() != 0</code>.</p>
 948 </div>
 949 <div class="admonitionblock note">
 950 <table>
 951 <tr>
 952 <td class="icon">
 953 <div class="title">Note</div>
 954 </td>
 955 <td class="content">
 956 On C++03 compilers, the return value is of an unspecified type.
 957 </td>
 958 </tr>
 959 </table>
 960 </div>
 961 </div>
 962 <div class="sect3">
 963 <h4 id="scoped_ptr_swap">swap</h4>
 964 <div class="literalblock">
 965 <div class="content">
 966 <pre>void swap(scoped_ptr &amp; b) noexcept;</pre>
 967 </div>
 968 </div>
 969 <div class="paragraph">
 970 <p>Exchanges the contents of the two smart pointers. <code>T</code> need not be a complete type.</p>
 971 </div>
 972 </div>
 973 </div>
 974 <div class="sect2">
 975 <h3 id="scoped_ptr_free_functions">Free Functions</h3>
 976 <div class="sect3">
 977 <h4 id="scoped_ptr_swap_2">swap</h4>
 978 <div class="literalblock">
 979 <div class="content">
 980 <pre>template&lt;class T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b) noexcept;</pre>
 981 </div>
 982 </div>
 983 <div class="paragraph">
 984 <p>Equivalent to <code>a.swap(b)</code>.</p>
 985 </div>
 986 </div>
 987 <div class="sect3">
 988 <h4 id="scoped_ptr_comparisons">comparisons</h4>
 989 <div class="literalblock">
 990 <div class="content">
 991 <pre>template&lt;class T&gt; bool operator==( scoped_ptr&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;</pre>
 992 </div>
 993 </div>
 994 <div class="literalblock">
 995 <div class="content">
 996 <pre>template&lt;class T&gt; bool operator==( std::nullptr_t, scoped_ptr&lt;T&gt; const &amp; p ) noexcept;</pre>
 997 </div>
 998 </div>
 999 <div class="paragraph">
1000 <p>Returns <code>p.get() == nullptr</code>.</p>
1001 </div>
1002 <div class="literalblock">
1003 <div class="content">
1004 <pre>template&lt;class T&gt; bool operator!=( scoped_ptr&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;</pre>
1005 </div>
1006 </div>
1007 <div class="literalblock">
1008 <div class="content">
1009 <pre>template&lt;class T&gt; bool operator!=( std::nullptr_t, scoped_ptr&lt;T&gt; const &amp; p ) noexcept;</pre>
1010 </div>
1011 </div>
1012 <div class="paragraph">
1013 <p>Returns <code>p.get() != nullptr</code>.</p>
1014 </div>
1015 </div>
1016 </div>
1017 <div class="sect2">
1018 <h3 id="scoped_ptr_example">Example</h3>
1019 <div class="paragraph">
1020 <p>Here&#8217;s an example that uses <code>scoped_ptr</code>.</p>
1021 </div>
1022 <div class="listingblock">
1023 <div class="content">
1024 <pre class="highlight"><code>#include &lt;boost/scoped_ptr.hpp&gt;
1025 #include &lt;iostream&gt;
1026
1027 struct Shoe { ~Shoe() { std::cout &lt;&lt; "Buckle my shoe\n"; } };
1028
1029 class MyClass {
1030     boost::scoped_ptr&lt;int&gt; ptr;
1031   public:
1032     MyClass() : ptr(new int) { *ptr = 0; }
1033     int add_one() { return ++*ptr; }
1034 };
1035
1036 int main()
1037 {
1038     boost::scoped_ptr&lt;Shoe&gt; x(new Shoe);
1039     MyClass my_instance;
1040     std::cout &lt;&lt; my_instance.add_one() &lt;&lt; '\n';
1041     std::cout &lt;&lt; my_instance.add_one() &lt;&lt; '\n';
1042 }</code></pre>
1043 </div>
1044 </div>
1045 <div class="paragraph">
1046 <p>The example program produces the beginning of a child&#8217;s nursery rhyme:</p>
1047 </div>
1048 <div class="listingblock">
1049 <div class="content">
1050 <pre class="highlight"><code>1
1051 2
1052 Buckle my shoe</code></pre>
1053 </div>
1054 </div>
1055 </div>
1056 <div class="sect2">
1057 <h3 id="scoped_ptr_rationale">Rationale</h3>
1058 <div class="paragraph">
1059 <p>The primary reason to use <code>scoped_ptr</code> rather than <code>std::auto_ptr</code> or <code>std::unique_ptr</code> is to let readers of your code
1060 know that you intend "resource acquisition is initialization" to be applied only for the current scope, and have no intent to transfer ownership.</p>
1061 </div>
1062 <div class="paragraph">
1063 <p>A secondary reason to use <code>scoped_ptr</code> is to prevent a later maintenance programmer from adding a function that transfers
1064 ownership by returning the <code>auto_ptr</code>, because the maintenance programmer saw <code>auto_ptr</code>, and assumed ownership could safely be transferred.</p>
1065 </div>
1066 <div class="paragraph">
1067 <p>Think of <code>bool</code> vs <code>int</code>. We all know that under the covers <code>bool</code> is usually just an <code>int</code>. Indeed, some argued against including bool in the C&#43;&#43;
1068 standard because of that. But by coding <code>bool</code> rather than <code>int</code>, you tell your readers what your intent is. Same with <code>scoped_ptr</code>; by using it you are signaling intent.</p>
1069 </div>
1070 <div class="paragraph">
1071 <p>It has been suggested that <code>scoped_ptr&lt;T&gt;</code> is equivalent to <code>std::auto_ptr&lt;T&gt; const</code>. Ed Brey pointed out, however, that <code>reset</code> will not work on a <code>std::auto_ptr&lt;T&gt; const</code>.</p>
1072 </div>
1073 </div>
1074 <div class="sect2">
1075 <h3 id="scoped_ptr_handlebody_idiom">Handle/Body Idiom</h3>
1076 <div class="paragraph">
1077 <p>One common usage of <code>scoped_ptr</code> is to implement a handle/body (also called pimpl) idiom which avoids exposing the body (implementation) in the header file.</p>
1078 </div>
1079 <div class="paragraph">
1080 <p>The <code><a href="../../example/scoped_ptr_example_test.cpp">scoped_ptr_example_test.cpp</a></code> sample program includes a header file,
1081 <code><a href="../../example/scoped_ptr_example.hpp">scoped_ptr_example.hpp</a></code>, which uses a <code>scoped_ptr&lt;&gt;</code> to an incomplete type to hide the
1082 implementation. The instantiation of member functions which require a complete type occurs in the <code><a href="../../example/scoped_ptr_example.cpp">scoped_ptr_example.cpp</a></code>
1083 implementation file.</p>
1084 </div>
1085 </div>
1086 <div class="sect2">
1087 <h3 id="scoped_ptr_frequently_asked_questions">Frequently Asked Questions</h3>
1088 <div class="qlist qanda">
1089 <ol>
1090 <li>
1091 <p><em>Why doesn&#8217;t <code>scoped_ptr</code> have a <code>release()</code> member?</em></p>
1092 <p>When reading source code, it is valuable to be able to draw conclusions about program behavior based on the types being used. If <code>scoped_ptr</code> had a <code>release()</code> member,
1093 it would become possible to transfer ownership of the held pointer, weakening its role as a way of limiting resource lifetime to a given context. Use <code>std::auto_ptr</code> where
1094 transfer of ownership is required. (supplied by Dave Abrahams)</p>
1095 </li>
1096 </ol>
1097 </div>
1098 </div>
1099 </div>
1100 </div>
1101 <div class="sect1">
1102 <h2 id="scoped_array">scoped_array: Scoped Array Ownership</h2>
1103 <div class="sectionbody">
1104 <div class="sect2">
1105 <h3 id="scoped_array_description">Description</h3>
1106 <div class="paragraph">
1107 <p>The <code>scoped_array</code> class template stores a pointer to a dynamically allocated array.
1108 (Dynamically allocated arrays are allocated with the C&#43;&#43; <code>new[]</code> expression.) The array
1109 pointed to is guaranteed to be deleted, either on destruction of the <code>scoped_array</code>,
1110 or via an explicit <code>reset</code>.</p>
1111 </div>
1112 <div class="paragraph">
1113 <p>The <code>scoped_array</code> template is a simple solution for simple needs. It supplies a basic
1114 "resource acquisition is initialization" facility, without shared-ownership or
1115 transfer-of-ownership semantics. Both its name and enforcement of semantics
1116 (by being  noncopyable) signal its intent to retain ownership solely within the current scope.
1117 Because it is noncopyable, it is safer than <code>shared_ptr&lt;T[]&gt;</code> for pointers which should not be copied.</p>
1118 </div>
1119 <div class="paragraph">
1120 <p>Because <code>scoped_array</code> is so simple, in its usual implementation every operation is as fast as a
1121 built-in array pointer and it has no more space overhead that a built-in array pointer.</p>
1122 </div>
1123 <div class="paragraph">
1124 <p>It cannot be used in C&#43;&#43; standard library containers. See <code>shared_ptr&lt;T[]&gt;</code> if <code>scoped_array</code>
1125 does not meet your needs.</p>
1126 </div>
1127 <div class="paragraph">
1128 <p>It cannot correctly hold a pointer to a single object. See <code>scoped_ptr</code> for that usage.</p>
1129 </div>
1130 <div class="paragraph">
1131 <p><code>std::vector</code> is an alternative to <code>scoped_array</code> that is a bit heavier duty but far more flexible.
1132 <code>boost::array</code> is an alternative that does not use dynamic allocation.</p>
1133 </div>
1134 <div class="paragraph">
1135 <p>The class template is parameterized on <code>T</code>, the type of the object pointed to.</p>
1136 </div>
1137 </div>
1138 <div class="sect2">
1139 <h3 id="scoped_array_synopsis">Synopsis</h3>
1140 <div class="paragraph">
1141 <p><code>scoped_array</code> is defined in <code>&lt;boost/smart_ptr/scoped_array.hpp&gt;</code>.</p>
1142 </div>
1143 <div class="listingblock">
1144 <div class="content">
1145 <pre class="highlight"><code>namespace boost {
1146
1147   template&lt;class T&gt; class scoped_array {
1148   private:
1149
1150     scoped_array(scoped_array const &amp;);
1151     scoped_array &amp; operator=(scoped_array const &amp;);
1152
1153     void operator==( scoped_array const&amp; ) const;
1154     void operator!=( scoped_array const&amp; ) const;
1155
1156   public:
1157
1158     typedef T element_type;
1159
1160     explicit scoped_array(T * p = 0) noexcept;
1161     ~scoped_array() noexcept;
1162
1163     void reset(T * p = 0) noexcept;
1164
1165     T &amp; operator[](std::ptrdiff_t i) const noexcept;
1166     T * get() const noexcept;
1167
1168     explicit operator bool () const noexcept;
1169
1170     void swap(scoped_array &amp; b) noexcept;
1171   };
1172
1173   template&lt;class T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b) noexcept;
1174
1175   template&lt;class T&gt;
1176     bool operator==( scoped_array&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;
1177   template&lt;class T&gt;
1178     bool operator==( std::nullptr_t, scoped_array&lt;T&gt; const &amp; p ) noexcept;
1179
1180   template&lt;class T&gt;
1181     bool operator!=( scoped_array&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;
1182   template&lt;class T&gt;
1183     bool operator!=( std::nullptr_t, scoped_array&lt;T&gt; const &amp; p ) noexcept;
1184 }</code></pre>
1185 </div>
1186 </div>
1187 </div>
1188 <div class="sect2">
1189 <h3 id="scoped_array_members">Members</h3>
1190 <div class="sect3">
1191 <h4 id="scoped_array_element_type">element_type</h4>
1192 <div class="literalblock">
1193 <div class="content">
1194 <pre>typedef T element_type;</pre>
1195 </div>
1196 </div>
1197 <div class="paragraph">
1198 <p>Provides the type of the stored pointer.</p>
1199 </div>
1200 </div>
1201 <div class="sect3">
1202 <h4 id="scoped_array_constructors">constructors</h4>
1203 <div class="literalblock">
1204 <div class="content">
1205 <pre>explicit scoped_array(T * p = 0) noexcept;</pre>
1206 </div>
1207 </div>
1208 <div class="paragraph">
1209 <p>Constructs a <code>scoped_array</code>, storing a copy of <code>p</code>, which must have been
1210 allocated via a C&#43;&#43; <code>new[]</code> expression or be 0. <code>T</code> is not required be a complete type.</p>
1211 </div>
1212 </div>
1213 <div class="sect3">
1214 <h4 id="scoped_array_destructor">destructor</h4>
1215 <div class="literalblock">
1216 <div class="content">
1217 <pre>~scoped_array() noexcept;</pre>
1218 </div>
1219 </div>
1220 <div class="paragraph">
1221 <p>Deletes the array pointed to by the stored pointer. Note that <code>delete[]</code> on a pointer with
1222 a value of 0 is harmless. <code>T</code> must be complete, and <code>delete[]</code> on the stored pointer must
1223 not throw exceptions.</p>
1224 </div>
1225 </div>
1226 <div class="sect3">
1227 <h4 id="scoped_array_reset">reset</h4>
1228 <div class="literalblock">
1229 <div class="content">
1230 <pre>void reset(T * p = 0) noexcept;</pre>
1231 </div>
1232 </div>
1233 <div class="paragraph">
1234 <p>Deletes the array pointed to by the stored pointer and then stores a copy of <code>p</code>,
1235 which must have been allocated via a C&#43;&#43; <code>new[]</code> expression or be 0. <code>T</code> must be complete,
1236 and <code>delete[]</code> on the stored pointer must not throw exceptions.</p>
1237 </div>
1238 </div>
1239 <div class="sect3">
1240 <h4 id="scoped_array_subscripting">subscripting</h4>
1241 <div class="literalblock">
1242 <div class="content">
1243 <pre>T &amp; operator[](std::ptrdiff_t i) const noexcept;</pre>
1244 </div>
1245 </div>
1246 <div class="paragraph">
1247 <p>Returns a reference to element <code>i</code> of the array pointed to by the stored pointer.
1248 Behavior is undefined and almost certainly undesirable if the stored pointer is 0,
1249 or if <code>i</code> is less than 0 or is greater than or equal to the number of elements in
1250 the array.</p>
1251 </div>
1252 </div>
1253 <div class="sect3">
1254 <h4 id="scoped_array_get">get</h4>
1255 <div class="literalblock">
1256 <div class="content">
1257 <pre>T * get() const noexcept;</pre>
1258 </div>
1259 </div>
1260 <div class="paragraph">
1261 <p>Returns the stored pointer. <code>T</code> need not be a complete type.</p>
1262 </div>
1263 </div>
1264 <div class="sect3">
1265 <h4 id="scoped_array_conversions">conversions</h4>
1266 <div class="literalblock">
1267 <div class="content">
1268 <pre>explicit operator bool () const noexcept;</pre>
1269 </div>
1270 </div>
1271 <div class="paragraph">
1272 <p>Returns <code>get() != 0</code>.</p>
1273 </div>
1274 <div class="admonitionblock note">
1275 <table>
1276 <tr>
1277 <td class="icon">
1278 <div class="title">Note</div>
1279 </td>
1280 <td class="content">
1281 On C++03 compilers, the return value is of an unspecified type.
1282 </td>
1283 </tr>
1284 </table>
1285 </div>
1286 </div>
1287 <div class="sect3">
1288 <h4 id="scoped_array_swap">swap</h4>
1289 <div class="literalblock">
1290 <div class="content">
1291 <pre>void swap(scoped_array &amp; b) noexcept;</pre>
1292 </div>
1293 </div>
1294 <div class="paragraph">
1295 <p>Exchanges the contents of the two smart pointers. <code>T</code> need not be a complete type.</p>
1296 </div>
1297 </div>
1298 </div>
1299 <div class="sect2">
1300 <h3 id="scoped_array_free_functions">Free Functions</h3>
1301 <div class="sect3">
1302 <h4 id="scoped_array_swap_2">swap</h4>
1303 <div class="literalblock">
1304 <div class="content">
1305 <pre>template&lt;class T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b) noexcept;</pre>
1306 </div>
1307 </div>
1308 <div class="paragraph">
1309 <p>Equivalent to <code>a.swap(b)</code>.</p>
1310 </div>
1311 </div>
1312 <div class="sect3">
1313 <h4 id="scoped_array_comparisons">comparisons</h4>
1314 <div class="literalblock">
1315 <div class="content">
1316 <pre>template&lt;class T&gt;
1317   bool operator==( scoped_array&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;</pre>
1318 </div>
1319 </div>
1320 <div class="literalblock">
1321 <div class="content">
1322 <pre>template&lt;class T&gt;
1323   bool operator==( std::nullptr_t, scoped_array&lt;T&gt; const &amp; p ) noexcept;</pre>
1324 </div>
1325 </div>
1326 <div class="paragraph">
1327 <p>Returns <code>p.get() == nullptr</code>.</p>
1328 </div>
1329 <div class="literalblock">
1330 <div class="content">
1331 <pre>template&lt;class T&gt;
1332   bool operator!=( scoped_array&lt;T&gt; const &amp; p, std::nullptr_t ) noexcept;</pre>
1333 </div>
1334 </div>
1335 <div class="literalblock">
1336 <div class="content">
1337 <pre>template&lt;class T&gt;
1338   bool operator!=( std::nullptr_t, scoped_array&lt;T&gt; const &amp; p ) noexcept;</pre>
1339 </div>
1340 </div>
1341 <div class="paragraph">
1342 <p>Returns <code>p.get() != nullptr</code>.</p>
1343 </div>
1344 </div>
1345 </div>
1346 </div>
1347 </div>
1348 <div class="sect1">
1349 <h2 id="shared_ptr">shared_ptr: Shared Ownership</h2>
1350 <div class="sectionbody">
1351 <div class="sect2">
1352 <h3 id="shared_ptr_description">Description</h3>
1353 <div class="paragraph">
1354 <p>The <code>shared_ptr</code> class template stores a pointer to a dynamically allocated object, typically with a C&#43;&#43; <code>new</code>-expression.
1355 The object pointed to is guaranteed to be deleted when the last <code>shared_ptr</code> pointing to it is destroyed or reset.</p>
1356 </div>
1357 <div class="listingblock">
1358 <div class="title">Code Example 1. Using shared_ptr</div>
1359 <div class="content">
1360 <pre class="highlight"><code>shared_ptr&lt;X&gt; p1( new X );
1361 shared_ptr&lt;void&gt; p2( new int(5) );</code></pre>
1362 </div>
1363 </div>
1364 <div class="paragraph">
1365 <p><code>shared_ptr</code> deletes the exact pointer that has been passed at construction time, complete with its original type, regardless
1366 of the template parameter. In the second example above, when <code>p2</code> is destroyed or reset, it will call <code>delete</code> on the original
1367 <code>int*</code> that has been passed to the constructor, even though <code>p2</code> itself is of type <code>shared_ptr&lt;void&gt;</code> and stores a pointer of
1368 type <code>void*</code>.</p>
1369 </div>
1370 <div class="paragraph">
1371 <p>Every <code>shared_ptr</code> meets the <code>CopyConstructible</code>, <code>MoveConstructible</code>, <code>CopyAssignable</code> and <code>MoveAssignable</code> requirements of the
1372 C&#43;&#43; Standard Library, and can be used in standard library containers. Comparison operators are supplied so that <code>shared_ptr</code>
1373 works with the standard library&#8217;s associative containers.</p>
1374 </div>
1375 <div class="paragraph">
1376 <p>Because the implementation uses reference counting, cycles of <code>shared_ptr</code> instances will not be reclaimed. For example, if <code>main()</code>
1377 holds a <code>shared_ptr</code> to <code>A</code>, which directly or indirectly holds a <code>shared_ptr</code> back to <code>A</code>, <code>A&#8217;s use count will be 2. Destruction
1378 of the original `shared_ptr</code> will leave <code>A</code> dangling with a use count of 1. Use <code><a href="#weak_ptr">weak_ptr</a></code> to "break cycles."</p>
1379 </div>
1380 <div class="paragraph">
1381 <p>The class template is parameterized on <code>T</code>, the type of the object pointed to. <code>shared_ptr</code> and most of its member functions place
1382 no requirements on <code>T</code>; it is allowed to be an incomplete type, or <code>void</code>. Member functions that do place additional requirements
1383 (constructors, <code>reset</code>) are explicitly documented below.</p>
1384 </div>
1385 <div class="paragraph">
1386 <p><code>shared_ptr&lt;T&gt;</code> can be implicitly converted to <code>shared_ptr&lt;U&gt;</code> whenever <code>T*</code> can be implicitly converted to <code>U*</code>. In particular,
1387 <code>shared_ptr&lt;T&gt;</code> is implicitly convertible to <code>shared_ptr&lt;T const&gt;</code>, to <code>shared_ptr&lt;U&gt;</code> where <code>U</code> is an accessible base of <code>T</code>,
1388 and to <code>shared_ptr&lt;void&gt;</code>.</p>
1389 </div>
1390 <div class="paragraph">
1391 <p><code>shared_ptr</code> is now part of the C++11 Standard, as <code>std::shared_ptr</code>.</p>
1392 </div>
1393 <div class="paragraph">
1394 <p>Starting with Boost release 1.53, <code>shared_ptr</code> can be used to hold a pointer to a dynamically allocated array. This is accomplished
1395 by using an array type (<code>T[]</code> or <code>T[N]</code>) as the template parameter. There is almost no difference between using an unsized array,
1396 <code>T[]</code>, and a sized array, <code>T[N]</code>; the latter just enables <code>operator[]</code> to perform a range check on the index.</p>
1397 </div>
1398 <div class="listingblock">
1399 <div class="title">Code Example 2. Using shared_ptr with arrays</div>
1400 <div class="content">
1401 <pre class="highlight"><code>shared_ptr&lt;double[1024]&gt; p1( new double[1024] );
1402 shared_ptr&lt;double[]&gt; p2( new double[n] );</code></pre>
1403 </div>
1404 </div>
1405 </div>
1406 <div class="sect2">
1407 <h3 id="shared_ptr_best_practices">Best Practices</h3>
1408 <div class="paragraph">
1409 <p>A simple guideline that nearly eliminates the possibility of memory leaks is: always use a named smart pointer variable to hold the result
1410 of <code>new</code>. Every occurence of the <code>new</code> keyword in the code should have the form:</p>
1411 </div>
1412 <div class="literalblock">
1413 <div class="content">
1414 <pre>shared_ptr&lt;T&gt; p(new Y);</pre>
1415 </div>
1416 </div>
1417 <div class="paragraph">
1418 <p>It is, of course, acceptable to use another smart pointer in place of <code>shared_ptr</code> above; having <code>T</code> and <code>Y</code> be the same type, or passing
1419 arguments to the constructor of <code>Y</code> is also OK.</p>
1420 </div>
1421 <div class="paragraph">
1422 <p>If you observe this guideline, it naturally follows that you will have no explicit <code>delete</code> statements; <code>try</code>/<code>catch</code> constructs will be rare.</p>
1423 </div>
1424 <div class="paragraph">
1425 <p>Avoid using unnamed <code>shared_ptr</code> temporaries to save typing; to see why this is dangerous, consider this example:</p>
1426 </div>
1427 <div class="listingblock">
1428 <div class="title">Code Example 3. Exception-safe and -unsafe use of shared_ptr</div>
1429 <div class="content">
1430 <pre class="highlight"><code>void f(shared_ptr&lt;int&gt;, int);
1431 int g();
1432
1433 void ok()
1434 {
1435     shared_ptr&lt;int&gt; p( new int(2) );
1436     f( p, g() );
1437 }
1438
1439 void bad()
1440 {
1441     f( shared_ptr&lt;int&gt;( new int(2) ), g() );
1442 }</code></pre>
1443 </div>
1444 </div>
1445 <div class="paragraph">
1446 <p>The function <code>ok</code> follows the guideline to the letter, whereas <code>bad</code> constructs the temporary <code>shared_ptr</code> in place, admitting the possibility of
1447 a memory leak. Since function arguments are evaluated in unspecified order, it is possible for <code>new int(2)</code> to be evaluated first, <code>g()</code> second,
1448 and we may never get to the <code>shared_ptr</code> constructor if <code>g</code> throws an exception. See <a href="http://www.gotw.ca/gotw/056.htm">Herb Sutter&#8217;s treatment</a> of
1449 the issue for more information.</p>
1450 </div>
1451 <div class="paragraph">
1452 <p>The exception safety problem described above may also be eliminated by using the <code><a href="#make_shared">make_shared</a></code> or <code>allocate_shared</code> factory
1453 functions defined in <code>&lt;boost/smart_ptr/make_shared.hpp&gt;</code>. These factory functions also provide an efficiency benefit by consolidating allocations.</p>
1454 </div>
1455 </div>
1456 <div class="sect2">
1457 <h3 id="shared_ptr_synopsis">Synopsis</h3>
1458 <div class="paragraph">
1459 <p><code>shared_ptr</code> is defined in <code>&lt;boost/smart_ptr/shared_ptr.hpp&gt;</code>.</p>
1460 </div>
1461 <div class="listingblock">
1462 <div class="content">
1463 <pre class="highlight"><code>namespace boost {
1464
1465   class bad_weak_ptr: public std::exception;
1466
1467   template&lt;class T&gt; class weak_ptr;
1468
1469   template&lt;class T&gt; class shared_ptr {
1470   public:
1471
1472     typedef /*see below*/ element_type;
1473
1474     constexpr shared_ptr() noexcept;
1475     constexpr shared_ptr(std::nullptr_t) noexcept;
1476
1477     template&lt;class Y&gt; explicit shared_ptr(Y * p);
1478     template&lt;class Y, class D&gt; shared_ptr(Y * p, D d);
1479     template&lt;class Y, class D, class A&gt; shared_ptr(Y * p, D d, A a);
1480     template&lt;class D&gt; shared_ptr(std::nullptr_t p, D d);
1481     template&lt;class D, class A&gt; shared_ptr(std::nullptr_t p, D d, A a);
1482
1483     ~shared_ptr() noexcept;
1484
1485     shared_ptr(shared_ptr const &amp; r) noexcept;
1486     template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r) noexcept;
1487
1488     shared_ptr(shared_ptr &amp;&amp; r) noexcept;
1489     template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r) noexcept;
1490
1491     template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;
1492     template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;
1493
1494     template&lt;class Y&gt; explicit shared_ptr(weak_ptr&lt;Y&gt; const &amp; r);
1495
1496     template&lt;class Y&gt; explicit shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);
1497     template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp;&amp; r);
1498
1499     template&lt;class Y, class D&gt; shared_ptr(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);
1500
1501     shared_ptr &amp; operator=(shared_ptr const &amp; r) noexcept;
1502     template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r) noexcept;
1503
1504     shared_ptr &amp; operator=(shared_ptr const &amp;&amp; r) noexcept;
1505     template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp;&amp; r) noexcept;
1506
1507     template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);
1508     template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp;&amp; r);
1509
1510     template&lt;class Y, class D&gt; shared_ptr &amp; operator=(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);
1511
1512     shared_ptr &amp; operator=(std::nullptr_t) noexcept;
1513
1514     void reset() noexcept;
1515
1516     template&lt;class Y&gt; void reset(Y * p);
1517     template&lt;class Y, class D&gt; void reset(Y * p, D d);
1518     template&lt;class Y, class D, class A&gt; void reset(Y * p, D d, A a);
1519
1520     template&lt;class Y&gt; void reset(shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;
1521     template&lt;class Y&gt; void reset(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;
1522
1523     T &amp; operator*() const noexcept; // only valid when T is not an array type
1524     T * operator-&gt;() const noexcept; // only valid when T is not an array type
1525
1526     // only valid when T is an array type
1527     element_type &amp; operator[](std::ptrdiff_t i) const noexcept;
1528
1529     element_type * get() const noexcept;
1530
1531     bool unique() const noexcept;
1532     long use_count() const noexcept;
1533
1534     explicit operator bool() const noexcept;
1535
1536     void swap(shared_ptr &amp; b) noexcept;
1537
1538     template&lt;class Y&gt; bool owner_before(shared_ptr&lt;Y&gt; const &amp; rhs) const noexcept;
1539     template&lt;class Y&gt; bool owner_before(weak_ptr&lt;Y&gt; const &amp; rhs) const noexcept;
1540   };
1541
1542   template&lt;class T, class U&gt;
1543     bool operator==(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;
1544
1545   template&lt;class T, class U&gt;
1546     bool operator!=(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;
1547
1548   template&lt;class T, class U&gt;
1549     bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;
1550
1551   template&lt;class T&gt; bool operator==(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;
1552   template&lt;class T&gt; bool operator==(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p) noexcept;
1553
1554   template&lt;class T&gt; bool operator!=(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;
1555   template&lt;class T&gt; bool operator!=(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p) noexcept;
1556
1557   template&lt;class T&gt; void swap(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b) noexcept;
1558
1559   template&lt;class T&gt;
1560     typename shared_ptr&lt;T&gt;::element_type *
1561       get_pointer(shared_ptr&lt;T&gt; const &amp; p) noexcept;
1562
1563   template&lt;class T, class U&gt;
1564     shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;
1565
1566   template&lt;class T, class U&gt;
1567     shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;
1568
1569   template&lt;class T, class U&gt;
1570     shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;
1571
1572   template&lt;class T, class U&gt;
1573     shared_ptr&lt;T&gt; reinterpret_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;
1574
1575   template&lt;class E, class T, class Y&gt;
1576     std::basic_ostream&lt;E, T&gt; &amp;
1577       operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);
1578
1579   template&lt;class D, class T&gt; D * get_deleter(shared_ptr&lt;T&gt; const &amp; p) noexcept;
1580
1581   template&lt;class T&gt; bool atomic_is_lock_free( shared_ptr&lt;T&gt; const * p ) noexcept;
1582
1583   template&lt;class T&gt; shared_ptr&lt;T&gt; atomic_load( shared_ptr&lt;T&gt; const * p ) noexcept;
1584   template&lt;class T&gt;
1585     shared_ptr&lt;T&gt; atomic_load_explicit( shared_ptr&lt;T&gt; const * p, int ) noexcept;
1586
1587   template&lt;class T&gt;
1588     void atomic_store( shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r ) noexcept;
1589   template&lt;class T&gt;
1590     void atomic_store_explicit( shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r, int ) noexcept;
1591
1592   template&lt;class T&gt;
1593     shared_ptr&lt;T&gt; atomic_exchange( shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r ) noexcept;
1594   template&lt;class T&gt;
1595     shared_ptr&lt;T&gt; atomic_exchange_explicit(
1596       shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r, int ) noexcept;
1597
1598   template&lt;class T&gt;
1599     bool atomic_compare_exchange(
1600       shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; * v, shared_ptr&lt;T&gt; w ) noexcept;
1601   template&lt;class T&gt;
1602     bool atomic_compare_exchange_explicit(
1603       shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; * v, shared_ptr&lt;T&gt; w, int, int ) noexcept;
1604 }</code></pre>
1605 </div>
1606 </div>
1607 </div>
1608 <div class="sect2">
1609 <h3 id="shared_ptr_members">Members</h3>
1610 <div class="sect3">
1611 <h4 id="shared_ptr_element_type">element_type</h4>
1612 <div class="listingblock">
1613 <div class="content">
1614 <pre class="highlight"><code>typedef ... element_type;</code></pre>
1615 </div>
1616 </div>
1617 <div class="paragraph">
1618 <p><code>element_type</code> is <code>T</code> when <code>T</code> is not an array type, and <code>U</code> when <code>T</code> is <code>U[]</code> or <code>U[N]</code>.</p>
1619 </div>
1620 </div>
1621 <div class="sect3">
1622 <h4 id="shared_ptr_default_constructor">default constructor</h4>
1623 <div class="listingblock">
1624 <div class="content">
1625 <pre class="highlight"><code>constexpr shared_ptr() noexcept;</code></pre>
1626 </div>
1627 </div>
1628 <div class="listingblock">
1629 <div class="content">
1630 <pre class="highlight"><code>constexpr shared_ptr(std::nullptr_t) noexcept;</code></pre>
1631 </div>
1632 </div>
1633 <div class="ulist none">
1634 <ul class="none">
1635 <li>
1636 <p></p>
1637 <div class="dlist">
1638 <dl>
1639 <dt class="hdlist1">Effects</dt>
1640 <dd>
1641 <p>Constructs an empty <code>shared_ptr</code>.</p>
1642 </dd>
1643 <dt class="hdlist1">Postconditions</dt>
1644 <dd>
1645 <p><code>use_count() == 0 &amp;&amp; get() == 0</code>.</p>
1646 </dd>
1647 </dl>
1648 </div>
1649 </li>
1650 </ul>
1651 </div>
1652 </div>
1653 <div class="sect3">
1654 <h4 id="shared_ptr_pointer_constructor">pointer constructor</h4>
1655 <div class="listingblock">
1656 <div class="content">
1657 <pre class="highlight"><code>template&lt;class Y&gt; explicit shared_ptr(Y * p);</code></pre>
1658 </div>
1659 </div>
1660 <div class="ulist none">
1661 <ul class="none">
1662 <li>
1663 <p></p>
1664 <div class="dlist">
1665 <dl>
1666 <dt class="hdlist1">Requires</dt>
1667 <dd>
1668 <p><code>Y</code> must be a complete type. The expression <code>delete[] p</code>, when <code>T</code> is an array type, or <code>delete p</code>, when <code>T</code> is not an array type,
1669 must be well-formed, well-defined, and not throw exceptions. When <code>T</code> is <code>U[N]</code>, <code>Y(*)[N]</code> must be convertible to <code>T*</code>; when <code>T</code> is <code>U[]</code>, <code>Y(*)[]</code>
1670 must be convertible to <code>T*</code>; otherwise, <code>Y*</code> must be convertible to <code>T*</code>.</p>
1671 </dd>
1672 <dt class="hdlist1">Effects</dt>
1673 <dd>
1674 <p>When <code>T</code> is not an array type, constructs a <code>shared_ptr</code> that owns the pointer <code>p</code>. Otherwise, constructs a <code>shared_ptr</code> that owns <code>p</code> and
1675 a deleter of an unspecified type that calls <code>delete[] p</code>.</p>
1676 </dd>
1677 <dt class="hdlist1">Postconditions</dt>
1678 <dd>
1679 <p><code>use_count() == 1 &amp;&amp; get() == p</code>. If <code>T</code> is not an array type and <code>p</code> is unambiguously convertible to <code>enable_shared_from_this&lt;V&gt;*</code>
1680 for some <code>V</code>, <code>p-&gt;shared_from_this()</code> returns a copy of <code>*this</code>.</p>
1681 </dd>
1682 <dt class="hdlist1">Throws</dt>
1683 <dd>
1684 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
1685 </dd>
1686 <dt class="hdlist1">Exception safety</dt>
1687 <dd>
1688 <p>If an exception is thrown, the constructor calls <code>delete[] p</code>, when <code>T</code> is an array type, or <code>delete p</code>, when <code>T</code> is not an array type.</p>
1689 </dd>
1690 </dl>
1691 </div>
1692 </li>
1693 </ul>
1694 </div>
1695 <div class="admonitionblock note">
1696 <table>
1697 <tr>
1698 <td class="icon">
1699 <div class="title">Note</div>
1700 </td>
1701 <td class="content">
1702 <code>p</code> must be a pointer to an object that was allocated via a C&#43;&#43; <code>new</code> expression or be 0. The postcondition that use count is 1 holds even if <code>p</code>
1703 is 0; invoking <code>delete</code> on a pointer that has a value of 0 is harmless.
1704 </td>
1705 </tr>
1706 </table>
1707 </div>
1708 <div class="admonitionblock note">
1709 <table>
1710 <tr>
1711 <td class="icon">
1712 <div class="title">Note</div>
1713 </td>
1714 <td class="content">
1715 This constructor is a template in order to remember the actual pointer type passed. The destructor will call delete with the same pointer, complete
1716 with its original type, even when <code>T</code> does not have a virtual destructor, or is <code>void</code>.
1717 </td>
1718 </tr>
1719 </table>
1720 </div>
1721 </div>
1722 <div class="sect3">
1723 <h4 id="shared_ptr_constructors_taking_a_deleter">constructors taking a deleter</h4>
1724 <div class="listingblock">
1725 <div class="content">
1726 <pre class="highlight"><code>template&lt;class Y, class D&gt; shared_ptr(Y * p, D d);</code></pre>
1727 </div>
1728 </div>
1729 <div class="listingblock">
1730 <div class="content">
1731 <pre class="highlight"><code>template&lt;class Y, class D, class A&gt; shared_ptr(Y * p, D d, A a);</code></pre>
1732 </div>
1733 </div>
1734 <div class="listingblock">
1735 <div class="content">
1736 <pre class="highlight"><code>template&lt;class D&gt; shared_ptr(std::nullptr_t p, D d);</code></pre>
1737 </div>
1738 </div>
1739 <div class="listingblock">
1740 <div class="content">
1741 <pre class="highlight"><code>template&lt;class D, class A&gt; shared_ptr(std::nullptr_t p, D d, A a);</code></pre>
1742 </div>
1743 </div>
1744 <div class="ulist none">
1745 <ul class="none">
1746 <li>
1747 <p></p>
1748 <div class="dlist">
1749 <dl>
1750 <dt class="hdlist1">Requires</dt>
1751 <dd>
1752 <p><code>D</code> must be <code>CopyConstructible</code>. The copy constructor and destructor of <code>D</code> must not throw. The expression <code>d(p)</code> must be well-formed, well-defined,
1753 and not throw exceptions. <code>A</code> must be an <code>Allocator</code>, as described in section Allocator Requirements [allocator.requirements] of the C&#43;&#43; Standard.
1754 When <code>T</code> is <code>U[N]</code>, <code>Y(*)[N]</code> must be convertible to <code>T*</code>; when <code>T</code> is <code>U[]</code>, <code>Y(*)[]</code> must be convertible to <code>T*</code>; otherwise, <code>Y*</code> must be convertible to <code>T*</code>.</p>
1755 </dd>
1756 <dt class="hdlist1">Effects</dt>
1757 <dd>
1758 <p>Constructs a <code>shared_ptr</code> that owns the pointer <code>p</code> and the deleter <code>d</code>. The constructors taking an allocator a allocate memory using a copy of <code>a</code>.</p>
1759 </dd>
1760 <dt class="hdlist1">Postconditions</dt>
1761 <dd>
1762 <p><code>use_count() == 1 &amp;&amp; get() == p</code>. If <code>T</code> is not an array type and <code>p</code> is unambiguously convertible to <code>enable_shared_from_this&lt;V&gt;*</code> for some <code>V</code>,
1763 <code>p-&gt;shared_from_this()</code> returns a copy of <code>*this</code>.</p>
1764 </dd>
1765 <dt class="hdlist1">Throws</dt>
1766 <dd>
1767 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
1768 </dd>
1769 <dt class="hdlist1">Exception safety</dt>
1770 <dd>
1771 <p>If an exception is thrown, <code>d(p)</code> is called.</p>
1772 </dd>
1773 </dl>
1774 </div>
1775 </li>
1776 </ul>
1777 </div>
1778 <div class="admonitionblock note">
1779 <table>
1780 <tr>
1781 <td class="icon">
1782 <div class="title">Note</div>
1783 </td>
1784 <td class="content">
1785 When the the time comes to delete the object pointed to by <code>p</code>, the stored copy of <code>d</code> is invoked with the stored copy of <code>p</code> as an argument.
1786 </td>
1787 </tr>
1788 </table>
1789 </div>
1790 <div class="admonitionblock note">
1791 <table>
1792 <tr>
1793 <td class="icon">
1794 <div class="title">Note</div>
1795 </td>
1796 <td class="content">
1797 Custom deallocators allow a factory function returning a <code>shared_ptr</code> to insulate the user from its memory allocation strategy. Since the deallocator
1798 is not part of the type, changing the allocation strategy does not break source or binary compatibility, and does not require a client recompilation. For example,
1799 a "no-op" deallocator is useful when returning a <code>shared_ptr</code> to a statically allocated object, and other variations allow a <code>shared_ptr</code> to be used as a wrapper
1800 for another smart pointer, easing interoperability.
1801 </td>
1802 </tr>
1803 </table>
1804 </div>
1805 <div class="admonitionblock note">
1806 <table>
1807 <tr>
1808 <td class="icon">
1809 <div class="title">Note</div>
1810 </td>
1811 <td class="content">
1812 The requirement that the copy constructor of <code>D</code> does not throw comes from the pass by value. If the copy constructor throws, the pointer would leak.
1813 </td>
1814 </tr>
1815 </table>
1816 </div>
1817 </div>
1818 <div class="sect3">
1819 <h4 id="shared_ptr_copy_and_converting_constructors">copy and converting constructors</h4>
1820 <div class="listingblock">
1821 <div class="content">
1822 <pre class="highlight"><code>shared_ptr(shared_ptr const &amp; r) noexcept;</code></pre>
1823 </div>
1824 </div>
1825 <div class="listingblock">
1826 <div class="content">
1827 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
1828 </div>
1829 </div>
1830 <div class="ulist none">
1831 <ul class="none">
1832 <li>
1833 <p></p>
1834 <div class="dlist">
1835 <dl>
1836 <dt class="hdlist1">Requires</dt>
1837 <dd>
1838 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
1839 </dd>
1840 <dt class="hdlist1">Effects</dt>
1841 <dd>
1842 <p>If <code>r</code> is empty, constructs an empty <code>shared_ptr</code>; otherwise, constructs a <code>shared_ptr</code> that shares ownership with <code>r</code>.</p>
1843 </dd>
1844 <dt class="hdlist1">Postconditions</dt>
1845 <dd>
1846 <p><code>get() == r.get() &amp;&amp; use_count() == r.use_count()</code>.</p>
1847 </dd>
1848 </dl>
1849 </div>
1850 </li>
1851 </ul>
1852 </div>
1853 </div>
1854 <div class="sect3">
1855 <h4 id="shared_ptr_move_constructors">move constructors</h4>
1856 <div class="listingblock">
1857 <div class="content">
1858 <pre class="highlight"><code>shared_ptr(shared_ptr &amp;&amp; r) noexcept;</code></pre>
1859 </div>
1860 </div>
1861 <div class="listingblock">
1862 <div class="content">
1863 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r) noexcept;</code></pre>
1864 </div>
1865 </div>
1866 <div class="ulist none">
1867 <ul class="none">
1868 <li>
1869 <p></p>
1870 <div class="dlist">
1871 <dl>
1872 <dt class="hdlist1">Requires</dt>
1873 <dd>
1874 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
1875 </dd>
1876 <dt class="hdlist1">Effects</dt>
1877 <dd>
1878 <p>Move-constructs a <code>shared_ptr</code> from <code>r</code>.</p>
1879 </dd>
1880 <dt class="hdlist1">Postconditions</dt>
1881 <dd>
1882 <p><code>*this</code> contains the old value of <code>r</code>. <code>r</code> is empty and <code>r.get() == 0</code>.</p>
1883 </dd>
1884 </dl>
1885 </div>
1886 </li>
1887 </ul>
1888 </div>
1889 </div>
1890 <div class="sect3">
1891 <h4 id="shared_ptr_aliasing_constructor">aliasing constructor</h4>
1892 <div class="listingblock">
1893 <div class="content">
1894 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;</code></pre>
1895 </div>
1896 </div>
1897 <div class="ulist none">
1898 <ul class="none">
1899 <li>
1900 <p></p>
1901 <div class="dlist">
1902 <dl>
1903 <dt class="hdlist1">Effects</dt>
1904 <dd>
1905 <p>Copy-constructs a <code>shared_ptr</code> from <code>r</code>, while storing <code>p</code> instead.</p>
1906 </dd>
1907 <dt class="hdlist1">Postconditions</dt>
1908 <dd>
1909 <p><code>get() == p &amp;&amp; use_count() == r.use_count()</code>.</p>
1910 </dd>
1911 </dl>
1912 </div>
1913 </li>
1914 </ul>
1915 </div>
1916 </div>
1917 <div class="sect3">
1918 <h4 id="shared_ptr_aliasing_move_constructor">aliasing move constructor</h4>
1919 <div class="listingblock">
1920 <div class="content">
1921 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;</code></pre>
1922 </div>
1923 </div>
1924 <div class="ulist none">
1925 <ul class="none">
1926 <li>
1927 <p></p>
1928 <div class="dlist">
1929 <dl>
1930 <dt class="hdlist1">Effects</dt>
1931 <dd>
1932 <p>Move-constructs a <code>shared_ptr</code> from <code>r</code>, while storing <code>p</code> instead.</p>
1933 </dd>
1934 <dt class="hdlist1">Postconditions</dt>
1935 <dd>
1936 <p><code>get() == p</code> and <code>use_count()</code> equals the old count of <code>r</code>. <code>r</code> is empty and <code>r.get() == 0</code>.</p>
1937 </dd>
1938 </dl>
1939 </div>
1940 </li>
1941 </ul>
1942 </div>
1943 </div>
1944 <div class="sect3">
1945 <h4 id="shared_ptr_weak_ptr_constructor">weak_ptr constructor</h4>
1946 <div class="listingblock">
1947 <div class="content">
1948 <pre class="highlight"><code>template&lt;class Y&gt; explicit shared_ptr(weak_ptr&lt;Y&gt; const &amp; r);</code></pre>
1949 </div>
1950 </div>
1951 <div class="ulist none">
1952 <ul class="none">
1953 <li>
1954 <p></p>
1955 <div class="dlist">
1956 <dl>
1957 <dt class="hdlist1">Requires</dt>
1958 <dd>
1959 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
1960 </dd>
1961 <dt class="hdlist1">Effects</dt>
1962 <dd>
1963 <p>Constructs a <code>shared_ptr</code> that shares ownership with <code>r</code> and stores a copy of the pointer stored in <code>r</code>.</p>
1964 </dd>
1965 <dt class="hdlist1">Postconditions</dt>
1966 <dd>
1967 <p><code>use_count() == r.use_count()</code>.</p>
1968 </dd>
1969 <dt class="hdlist1">Throws</dt>
1970 <dd>
1971 <p><code>bad_weak_ptr</code> when <code>r.use_count() == 0</code>.</p>
1972 </dd>
1973 <dt class="hdlist1">Exception safety</dt>
1974 <dd>
1975 <p>If an exception is thrown, the constructor has no effect.</p>
1976 </dd>
1977 </dl>
1978 </div>
1979 </li>
1980 </ul>
1981 </div>
1982 </div>
1983 <div class="sect3">
1984 <h4 id="shared_ptr_auto_ptr_constructors">auto_ptr constructors</h4>
1985 <div class="listingblock">
1986 <div class="content">
1987 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);</code></pre>
1988 </div>
1989 </div>
1990 <div class="listingblock">
1991 <div class="content">
1992 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp;&amp; r);</code></pre>
1993 </div>
1994 </div>
1995 <div class="ulist none">
1996 <ul class="none">
1997 <li>
1998 <p></p>
1999 <div class="dlist">
2000 <dl>
2001 <dt class="hdlist1">Requires</dt>
2002 <dd>
2003 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
2004 </dd>
2005 <dt class="hdlist1">Effects</dt>
2006 <dd>
2007 <p>Constructs a <code>shared_ptr</code>, as if by storing a copy of <code>r.release()</code>.</p>
2008 </dd>
2009 <dt class="hdlist1">Postconditions</dt>
2010 <dd>
2011 <p><code>use_count() == 1</code>.</p>
2012 </dd>
2013 <dt class="hdlist1">Throws</dt>
2014 <dd>
2015 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
2016 </dd>
2017 <dt class="hdlist1">Exception safety</dt>
2018 <dd>
2019 <p>If an exception is thrown, the constructor has no effect.</p>
2020 </dd>
2021 </dl>
2022 </div>
2023 </li>
2024 </ul>
2025 </div>
2026 </div>
2027 <div class="sect3">
2028 <h4 id="shared_ptr_unique_ptr_constructor">unique_ptr constructor</h4>
2029 <div class="listingblock">
2030 <div class="content">
2031 <pre class="highlight"><code>template&lt;class Y, class D&gt; shared_ptr(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);</code></pre>
2032 </div>
2033 </div>
2034 <div class="ulist none">
2035 <ul class="none">
2036 <li>
2037 <p></p>
2038 <div class="dlist">
2039 <dl>
2040 <dt class="hdlist1">Requires</dt>
2041 <dd>
2042 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
2043 </dd>
2044 <dt class="hdlist1">Effects</dt>
2045 <dd>
2046 <div class="ulist">
2047 <ul>
2048 <li>
2049 <p>When <code>r.get() == 0</code>, equivalent to <code>shared_ptr()</code>;</p>
2050 </li>
2051 <li>
2052 <p>When <code>D</code> is not a reference type, equivalent to <code>shared_ptr(r.release(), r.get_deleter())</code>;</p>
2053 </li>
2054 <li>
2055 <p>Otherwise, equivalent to <code>shared_ptr(r.release(), del)</code>, where <code>del</code> is a deleter that stores the reference <code>rd</code> returned
2056 from <code>r.get_deleter()</code> and <code>del(p)</code> calls <code>rd(p)</code>.</p>
2057 </li>
2058 </ul>
2059 </div>
2060 </dd>
2061 <dt class="hdlist1">Throws</dt>
2062 <dd>
2063 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
2064 </dd>
2065 <dt class="hdlist1">Exception safety</dt>
2066 <dd>
2067 <p>If an exception is thrown, the constructor has no effect.</p>
2068 </dd>
2069 </dl>
2070 </div>
2071 </li>
2072 </ul>
2073 </div>
2074 </div>
2075 <div class="sect3">
2076 <h4 id="shared_ptr_destructor">destructor</h4>
2077 <div class="listingblock">
2078 <div class="content">
2079 <pre class="highlight"><code>~shared_ptr() noexcept;</code></pre>
2080 </div>
2081 </div>
2082 <div class="ulist none">
2083 <ul class="none">
2084 <li>
2085 <p></p>
2086 <div class="dlist">
2087 <dl>
2088 <dt class="hdlist1">Effects</dt>
2089 <dd>
2090 <div class="ulist">
2091 <ul>
2092 <li>
2093 <p>If <code>*this</code> is empty, or shares ownership with another <code>shared_ptr</code> instance (<code>use_count() &gt; 1</code>), there are no side effects.</p>
2094 </li>
2095 <li>
2096 <p>Otherwise, if <code>*this</code> owns a pointer <code>p</code> and a deleter <code>d</code>, <code>d(p)</code> is called.</p>
2097 </li>
2098 <li>
2099 <p>Otherwise, <code>*this</code> owns a pointer <code>p</code>, and <code>delete p</code> is called.</p>
2100 </li>
2101 </ul>
2102 </div>
2103 </dd>
2104 </dl>
2105 </div>
2106 </li>
2107 </ul>
2108 </div>
2109 </div>
2110 <div class="sect3">
2111 <h4 id="shared_ptr_assignment">assignment</h4>
2112 <div class="listingblock">
2113 <div class="content">
2114 <pre class="highlight"><code>shared_ptr &amp; operator=(shared_ptr const &amp; r) noexcept;</code></pre>
2115 </div>
2116 </div>
2117 <div class="listingblock">
2118 <div class="content">
2119 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
2120 </div>
2121 </div>
2122 <div class="listingblock">
2123 <div class="content">
2124 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);</code></pre>
2125 </div>
2126 </div>
2127 <div class="ulist none">
2128 <ul class="none">
2129 <li>
2130 <p></p>
2131 <div class="dlist">
2132 <dl>
2133 <dt class="hdlist1">Effects</dt>
2134 <dd>
2135 <p>Equivalent to <code>shared_ptr(r).swap(*this)</code>.</p>
2136 </dd>
2137 <dt class="hdlist1">Returns</dt>
2138 <dd>
2139 <p><code>*this</code>.</p>
2140 </dd>
2141 </dl>
2142 </div>
2143 </li>
2144 </ul>
2145 </div>
2146 <div class="admonitionblock note">
2147 <table>
2148 <tr>
2149 <td class="icon">
2150 <div class="title">Note</div>
2151 </td>
2152 <td class="content">
2153 The use count updates caused by the temporary object construction and destruction are not considered observable side effects,
2154 and the implementation is free to meet the effects (and the implied guarantees) via different means, without creating a temporary.
2155 </td>
2156 </tr>
2157 </table>
2158 </div>
2159 <div class="admonitionblock note">
2160 <table>
2161 <tr>
2162 <td class="icon">
2163 <div class="title">Note</div>
2164 </td>
2165 <td class="content">
2166 <div class="paragraph">
2167 <p>In particular, in the example:</p>
2168 </div>
2169 <div class="listingblock">
2170 <div class="content">
2171 <pre class="highlight"><code>shared_ptr&lt;int&gt; p(new int);
2172 shared_ptr&lt;void&gt; q(p);
2173 p = p;
2174 q = p;</code></pre>
2175 </div>
2176 </div>
2177 <div class="paragraph">
2178 <p>both assignments may be no-ops.</p>
2179 </div>
2180 </td>
2181 </tr>
2182 </table>
2183 </div>
2184 <div class="listingblock">
2185 <div class="content">
2186 <pre class="highlight"><code>shared_ptr &amp; operator=(shared_ptr &amp;&amp; r) noexcept;</code></pre>
2187 </div>
2188 </div>
2189 <div class="listingblock">
2190 <div class="content">
2191 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; &amp;&amp; r) noexcept;</code></pre>
2192 </div>
2193 </div>
2194 <div class="listingblock">
2195 <div class="content">
2196 <pre class="highlight"><code>template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp;&amp; r);</code></pre>
2197 </div>
2198 </div>
2199 <div class="listingblock">
2200 <div class="content">
2201 <pre class="highlight"><code>template&lt;class Y, class D&gt; shared_ptr &amp; operator=(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);</code></pre>
2202 </div>
2203 </div>
2204 <div class="ulist none">
2205 <ul class="none">
2206 <li>
2207 <p></p>
2208 <div class="dlist">
2209 <dl>
2210 <dt class="hdlist1">Effects</dt>
2211 <dd>
2212 <p>Equivalent to <code>shared_ptr(std::move(r)).swap(*this)</code>.</p>
2213 </dd>
2214 <dt class="hdlist1">Returns</dt>
2215 <dd>
2216 <p><code>*this</code>.</p>
2217 </dd>
2218 </dl>
2219 </div>
2220 </li>
2221 </ul>
2222 </div>
2223 <div class="listingblock">
2224 <div class="content">
2225 <pre class="highlight"><code>shared_ptr &amp; operator=(std::nullptr_t) noexcept;</code></pre>
2226 </div>
2227 </div>
2228 <div class="ulist none">
2229 <ul class="none">
2230 <li>
2231 <p></p>
2232 <div class="dlist">
2233 <dl>
2234 <dt class="hdlist1">Effects</dt>
2235 <dd>
2236 <p>Equivalent to <code>shared_ptr().swap(*this)</code>.</p>
2237 </dd>
2238 <dt class="hdlist1">Returns</dt>
2239 <dd>
2240 <p><code>*this</code>.</p>
2241 </dd>
2242 </dl>
2243 </div>
2244 </li>
2245 </ul>
2246 </div>
2247 </div>
2248 <div class="sect3">
2249 <h4 id="shared_ptr_reset">reset</h4>
2250 <div class="listingblock">
2251 <div class="content">
2252 <pre class="highlight"><code>void reset() noexcept;</code></pre>
2253 </div>
2254 </div>
2255 <div class="ulist none">
2256 <ul class="none">
2257 <li>
2258 <p></p>
2259 <div class="dlist">
2260 <dl>
2261 <dt class="hdlist1">Effects</dt>
2262 <dd>
2263 <p>Equivalent to <code>shared_ptr().swap(*this)</code>.</p>
2264 </dd>
2265 </dl>
2266 </div>
2267 </li>
2268 </ul>
2269 </div>
2270 <div class="listingblock">
2271 <div class="content">
2272 <pre class="highlight"><code>template&lt;class Y&gt; void reset(Y * p);</code></pre>
2273 </div>
2274 </div>
2275 <div class="ulist none">
2276 <ul class="none">
2277 <li>
2278 <p></p>
2279 <div class="dlist">
2280 <dl>
2281 <dt class="hdlist1">Effects</dt>
2282 <dd>
2283 <p>Equivalent to <code>shared_ptr(p).swap(*this)</code>.</p>
2284 </dd>
2285 </dl>
2286 </div>
2287 </li>
2288 </ul>
2289 </div>
2290 <div class="listingblock">
2291 <div class="content">
2292 <pre class="highlight"><code>template&lt;class Y, class D&gt; void reset(Y * p, D d);</code></pre>
2293 </div>
2294 </div>
2295 <div class="ulist none">
2296 <ul class="none">
2297 <li>
2298 <p></p>
2299 <div class="dlist">
2300 <dl>
2301 <dt class="hdlist1">Effects</dt>
2302 <dd>
2303 <p>Equivalent to <code>shared_ptr(p, d).swap(*this)</code>.</p>
2304 </dd>
2305 </dl>
2306 </div>
2307 </li>
2308 </ul>
2309 </div>
2310 <div class="listingblock">
2311 <div class="content">
2312 <pre class="highlight"><code>template&lt;class Y, class D, class A&gt; void reset(Y * p, D d, A a);</code></pre>
2313 </div>
2314 </div>
2315 <div class="ulist none">
2316 <ul class="none">
2317 <li>
2318 <p></p>
2319 <div class="dlist">
2320 <dl>
2321 <dt class="hdlist1">Effects</dt>
2322 <dd>
2323 <p>Equivalent to <code>shared_ptr(p, d, a).swap(*this)</code>.</p>
2324 </dd>
2325 </dl>
2326 </div>
2327 </li>
2328 </ul>
2329 </div>
2330 <div class="listingblock">
2331 <div class="content">
2332 <pre class="highlight"><code>template&lt;class Y&gt; void reset(shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;</code></pre>
2333 </div>
2334 </div>
2335 <div class="ulist none">
2336 <ul class="none">
2337 <li>
2338 <p></p>
2339 <div class="dlist">
2340 <dl>
2341 <dt class="hdlist1">Effects</dt>
2342 <dd>
2343 <p>Equivalent to <code>shared_ptr(r, p).swap(*this)</code>.</p>
2344 </dd>
2345 </dl>
2346 </div>
2347 </li>
2348 </ul>
2349 </div>
2350 <div class="listingblock">
2351 <div class="content">
2352 <pre class="highlight"><code>template&lt;class Y&gt; void reset(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;</code></pre>
2353 </div>
2354 </div>
2355 <div class="ulist none">
2356 <ul class="none">
2357 <li>
2358 <p></p>
2359 <div class="dlist">
2360 <dl>
2361 <dt class="hdlist1">Effects</dt>
2362 <dd>
2363 <p>Equivalent to <code>shared_ptr(std::move(r), p).swap(*this)</code>.</p>
2364 </dd>
2365 </dl>
2366 </div>
2367 </li>
2368 </ul>
2369 </div>
2370 </div>
2371 <div class="sect3">
2372 <h4 id="shared_ptr_indirection">indirection</h4>
2373 <div class="listingblock">
2374 <div class="content">
2375 <pre class="highlight"><code>T &amp; operator*() const noexcept;</code></pre>
2376 </div>
2377 </div>
2378 <div class="ulist none">
2379 <ul class="none">
2380 <li>
2381 <p></p>
2382 <div class="dlist">
2383 <dl>
2384 <dt class="hdlist1">Requires</dt>
2385 <dd>
2386 <p><code>T</code> should not be an array type. The stored pointer must not be 0.</p>
2387 </dd>
2388 <dt class="hdlist1">Returns</dt>
2389 <dd>
2390 <p><code>*get()</code>.</p>
2391 </dd>
2392 </dl>
2393 </div>
2394 </li>
2395 </ul>
2396 </div>
2397 <div class="listingblock">
2398 <div class="content">
2399 <pre class="highlight"><code>T * operator-&gt;() const noexcept;</code></pre>
2400 </div>
2401 </div>
2402 <div class="ulist none">
2403 <ul class="none">
2404 <li>
2405 <p></p>
2406 <div class="dlist">
2407 <dl>
2408 <dt class="hdlist1">Requires</dt>
2409 <dd>
2410 <p><code>T</code> should not be an array type. The stored pointer must not be 0.</p>
2411 </dd>
2412 <dt class="hdlist1">Returns</dt>
2413 <dd>
2414 <p><code>get()</code>.</p>
2415 </dd>
2416 </dl>
2417 </div>
2418 </li>
2419 </ul>
2420 </div>
2421 <div class="listingblock">
2422 <div class="content">
2423 <pre class="highlight"><code>element_type &amp; operator[](std::ptrdiff_t i) const noexcept;</code></pre>
2424 </div>
2425 </div>
2426 <div class="ulist none">
2427 <ul class="none">
2428 <li>
2429 <p></p>
2430 <div class="dlist">
2431 <dl>
2432 <dt class="hdlist1">Requires</dt>
2433 <dd>
2434 <p><code>T</code> should be an array type. The stored pointer must not be 0. <code>i &gt;= 0</code>. If <code>T</code> is <code>U[N]</code>, <code>i &lt; N</code>.</p>
2435 </dd>
2436 <dt class="hdlist1">Returns</dt>
2437 <dd>
2438 <p><code>get()[i]</code>.</p>
2439 </dd>
2440 </dl>
2441 </div>
2442 </li>
2443 </ul>
2444 </div>
2445 </div>
2446 <div class="sect3">
2447 <h4 id="shared_ptr_get">get</h4>
2448 <div class="listingblock">
2449 <div class="content">
2450 <pre class="highlight"><code>element_type * get() const noexcept;</code></pre>
2451 </div>
2452 </div>
2453 <div class="ulist none">
2454 <ul class="none">
2455 <li>
2456 <p></p>
2457 <div class="dlist">
2458 <dl>
2459 <dt class="hdlist1">Returns</dt>
2460 <dd>
2461 <p>The stored pointer.</p>
2462 </dd>
2463 </dl>
2464 </div>
2465 </li>
2466 </ul>
2467 </div>
2468 </div>
2469 <div class="sect3">
2470 <h4 id="shared_ptr_unique">unique</h4>
2471 <div class="listingblock">
2472 <div class="content">
2473 <pre class="highlight"><code>bool unique() const noexcept;</code></pre>
2474 </div>
2475 </div>
2476 <div class="ulist none">
2477 <ul class="none">
2478 <li>
2479 <p></p>
2480 <div class="dlist">
2481 <dl>
2482 <dt class="hdlist1">Returns</dt>
2483 <dd>
2484 <p><code>use_count() == 1</code>.</p>
2485 </dd>
2486 </dl>
2487 </div>
2488 </li>
2489 </ul>
2490 </div>
2491 </div>
2492 <div class="sect3">
2493 <h4 id="shared_ptr_use_count">use_count</h4>
2494 <div class="listingblock">
2495 <div class="content">
2496 <pre class="highlight"><code>long use_count() const noexcept;</code></pre>
2497 </div>
2498 </div>
2499 <div class="ulist none">
2500 <ul class="none">
2501 <li>
2502 <p></p>
2503 <div class="dlist">
2504 <dl>
2505 <dt class="hdlist1">Returns</dt>
2506 <dd>
2507 <p>The number of <code>shared_ptr</code> objects, <code>*this</code> included, that share ownership with <code>*this</code>, or 0 when <code>*this</code> is empty.</p>
2508 </dd>
2509 </dl>
2510 </div>
2511 </li>
2512 </ul>
2513 </div>
2514 </div>
2515 <div class="sect3">
2516 <h4 id="shared_ptr_conversions">conversions</h4>
2517 <div class="listingblock">
2518 <div class="content">
2519 <pre class="highlight"><code>explicit operator bool() const noexcept;</code></pre>
2520 </div>
2521 </div>
2522 <div class="ulist none">
2523 <ul class="none">
2524 <li>
2525 <p></p>
2526 <div class="dlist">
2527 <dl>
2528 <dt class="hdlist1">Returns</dt>
2529 <dd>
2530 <p><code>get() != 0</code>.</p>
2531 </dd>
2532 </dl>
2533 </div>
2534 </li>
2535 </ul>
2536 </div>
2537 <div class="admonitionblock note">
2538 <table>
2539 <tr>
2540 <td class="icon">
2541 <div class="title">Note</div>
2542 </td>
2543 <td class="content">
2544 This conversion operator allows <code>shared_ptr</code> objects to be used in boolean contexts, like <code>if(p &amp;&amp; p-&gt;valid()) {}</code>.
2545 </td>
2546 </tr>
2547 </table>
2548 </div>
2549 <div class="admonitionblock note">
2550 <table>
2551 <tr>
2552 <td class="icon">
2553 <div class="title">Note</div>
2554 </td>
2555 <td class="content">
2556 The conversion to <code>bool</code> is not merely syntactic sugar. It allows <code>shared_ptr</code> variables to be declared in conditions when using
2557 <code>dynamic_pointer_cast</code> or <code>weak_ptr::lock</code>.
2558 </td>
2559 </tr>
2560 </table>
2561 </div>
2562 <div class="admonitionblock note">
2563 <table>
2564 <tr>
2565 <td class="icon">
2566 <div class="title">Note</div>
2567 </td>
2568 <td class="content">
2569 On C++03 compilers, the return value is of an unspecified type.
2570 </td>
2571 </tr>
2572 </table>
2573 </div>
2574 </div>
2575 <div class="sect3">
2576 <h4 id="shared_ptr_swap">swap</h4>
2577 <div class="listingblock">
2578 <div class="content">
2579 <pre class="highlight"><code>void swap(shared_ptr &amp; b) noexcept;</code></pre>
2580 </div>
2581 </div>
2582 <div class="ulist none">
2583 <ul class="none">
2584 <li>
2585 <p></p>
2586 <div class="dlist">
2587 <dl>
2588 <dt class="hdlist1">Effects</dt>
2589 <dd>
2590 <p>Exchanges the contents of the two smart pointers.</p>
2591 </dd>
2592 </dl>
2593 </div>
2594 </li>
2595 </ul>
2596 </div>
2597 </div>
2598 <div class="sect3">
2599 <h4 id="shared_ptr_owner_before">owner_before</h4>
2600 <div class="listingblock">
2601 <div class="content">
2602 <pre class="highlight"><code>template&lt;class Y&gt; bool owner_before(shared_ptr&lt;Y&gt; const &amp; rhs) const noexcept;</code></pre>
2603 </div>
2604 </div>
2605 <div class="listingblock">
2606 <div class="content">
2607 <pre class="highlight"><code>template&lt;class Y&gt; bool owner_before(weak_ptr&lt;Y&gt; const &amp; rhs) const noexcept;</code></pre>
2608 </div>
2609 </div>
2610 <div class="ulist none">
2611 <ul class="none">
2612 <li>
2613 <p></p>
2614 <div class="dlist">
2615 <dl>
2616 <dt class="hdlist1">Effects</dt>
2617 <dd>
2618 <p>See the description of <code>operator&lt;</code>.</p>
2619 </dd>
2620 </dl>
2621 </div>
2622 </li>
2623 </ul>
2624 </div>
2625 </div>
2626 </div>
2627 <div class="sect2">
2628 <h3 id="shared_ptr_free_functions">Free Functions</h3>
2629 <div class="sect3">
2630 <h4 id="shared_ptr_comparison">comparison</h4>
2631 <div class="listingblock">
2632 <div class="content">
2633 <pre class="highlight"><code>template&lt;class T, class U&gt;
2634   bool operator==(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
2635 </div>
2636 </div>
2637 <div class="ulist none">
2638 <ul class="none">
2639 <li>
2640 <p></p>
2641 <div class="dlist">
2642 <dl>
2643 <dt class="hdlist1">Returns</dt>
2644 <dd>
2645 <p><code>a.get() == b.get()</code>.</p>
2646 </dd>
2647 </dl>
2648 </div>
2649 </li>
2650 </ul>
2651 </div>
2652 <div class="listingblock">
2653 <div class="content">
2654 <pre class="highlight"><code>template&lt;class T, class U&gt;
2655   bool operator!=(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
2656 </div>
2657 </div>
2658 <div class="ulist none">
2659 <ul class="none">
2660 <li>
2661 <p></p>
2662 <div class="dlist">
2663 <dl>
2664 <dt class="hdlist1">Returns</dt>
2665 <dd>
2666 <p><code>a.get() != b.get()</code>.</p>
2667 </dd>
2668 </dl>
2669 </div>
2670 </li>
2671 </ul>
2672 </div>
2673 <div class="listingblock">
2674 <div class="content">
2675 <pre class="highlight"><code>template&lt;class T&gt; bool operator==(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;</code></pre>
2676 </div>
2677 </div>
2678 <div class="listingblock">
2679 <div class="content">
2680 <pre class="highlight"><code>template&lt;class T&gt; bool operator==(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
2681 </div>
2682 </div>
2683 <div class="ulist none">
2684 <ul class="none">
2685 <li>
2686 <p></p>
2687 <div class="dlist">
2688 <dl>
2689 <dt class="hdlist1">Returns</dt>
2690 <dd>
2691 <p><code>p.get() == 0</code>.</p>
2692 </dd>
2693 </dl>
2694 </div>
2695 </li>
2696 </ul>
2697 </div>
2698 <div class="listingblock">
2699 <div class="content">
2700 <pre class="highlight"><code>template&lt;class T&gt; bool operator!=(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;</code></pre>
2701 </div>
2702 </div>
2703 <div class="listingblock">
2704 <div class="content">
2705 <pre class="highlight"><code>template&lt;class T&gt; bool operator!=(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
2706 </div>
2707 </div>
2708 <div class="ulist none">
2709 <ul class="none">
2710 <li>
2711 <p></p>
2712 <div class="dlist">
2713 <dl>
2714 <dt class="hdlist1">Returns</dt>
2715 <dd>
2716 <p><code>p.get() != 0</code>.</p>
2717 </dd>
2718 </dl>
2719 </div>
2720 </li>
2721 </ul>
2722 </div>
2723 <div class="listingblock">
2724 <div class="content">
2725 <pre class="highlight"><code>template&lt;class T, class U&gt;
2726   bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
2727 </div>
2728 </div>
2729 <div class="ulist none">
2730 <ul class="none">
2731 <li>
2732 <p></p>
2733 <div class="dlist">
2734 <dl>
2735 <dt class="hdlist1">Returns</dt>
2736 <dd>
2737 <p>An unspecified value such that</p>
2738 <div class="ulist">
2739 <ul>
2740 <li>
2741 <p><code>operator&lt;</code> is a strict weak ordering as described in section [lib.alg.sorting] of the C&#43;&#43; standard;</p>
2742 </li>
2743 <li>
2744 <p>under the equivalence relation defined by <code>operator&lt;</code>, <code>!(a &lt; b) &amp;&amp; !(b &lt; a)</code>, two <code>shared_ptr</code> instances
2745 are equivalent if and only if they share ownership or are both empty.</p>
2746 </li>
2747 </ul>
2748 </div>
2749 </dd>
2750 </dl>
2751 </div>
2752 </li>
2753 </ul>
2754 </div>
2755 <div class="admonitionblock note">
2756 <table>
2757 <tr>
2758 <td class="icon">
2759 <div class="title">Note</div>
2760 </td>
2761 <td class="content">
2762 Allows <code>shared_ptr</code> objects to be used as keys in associative containers.
2763 </td>
2764 </tr>
2765 </table>
2766 </div>
2767 <div class="admonitionblock note">
2768 <table>
2769 <tr>
2770 <td class="icon">
2771 <div class="title">Note</div>
2772 </td>
2773 <td class="content">
2774 The rest of the comparison operators are omitted by design.
2775 </td>
2776 </tr>
2777 </table>
2778 </div>
2779 </div>
2780 <div class="sect3">
2781 <h4 id="shared_ptr_swap_2">swap</h4>
2782 <div class="listingblock">
2783 <div class="content">
2784 <pre class="highlight"><code>template&lt;class T&gt; void swap(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b) noexcept;</code></pre>
2785 </div>
2786 </div>
2787 <div class="ulist none">
2788 <ul class="none">
2789 <li>
2790 <p></p>
2791 <div class="dlist">
2792 <dl>
2793 <dt class="hdlist1">Effects</dt>
2794 <dd>
2795 <p>Equivalent to <code>a.swap(b)</code>.</p>
2796 </dd>
2797 </dl>
2798 </div>
2799 </li>
2800 </ul>
2801 </div>
2802 </div>
2803 <div class="sect3">
2804 <h4 id="shared_ptr_get_pointer">get_pointer</h4>
2805 <div class="listingblock">
2806 <div class="content">
2807 <pre class="highlight"><code>template&lt;class T&gt;
2808   typename shared_ptr&lt;T&gt;::element_type *
2809     get_pointer(shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
2810 </div>
2811 </div>
2812 <div class="ulist none">
2813 <ul class="none">
2814 <li>
2815 <p></p>
2816 <div class="dlist">
2817 <dl>
2818 <dt class="hdlist1">Returns</dt>
2819 <dd>
2820 <p><code>p.get()</code>.</p>
2821 </dd>
2822 </dl>
2823 </div>
2824 </li>
2825 </ul>
2826 </div>
2827 <div class="admonitionblock note">
2828 <table>
2829 <tr>
2830 <td class="icon">
2831 <div class="title">Note</div>
2832 </td>
2833 <td class="content">
2834 Provided as an aid to generic programming. Used by <code>mem_fn</code>.
2835 </td>
2836 </tr>
2837 </table>
2838 </div>
2839 </div>
2840 <div class="sect3">
2841 <h4 id="shared_ptr_static_pointer_cast">static_pointer_cast</h4>
2842 <div class="listingblock">
2843 <div class="content">
2844 <pre class="highlight"><code>template&lt;class T, class U&gt;
2845   shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
2846 </div>
2847 </div>
2848 <div class="ulist none">
2849 <ul class="none">
2850 <li>
2851 <p></p>
2852 <div class="dlist">
2853 <dl>
2854 <dt class="hdlist1">Requires</dt>
2855 <dd>
2856 <p>The expression <code>static_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
2857 </dd>
2858 <dt class="hdlist1">Returns</dt>
2859 <dd>
2860 <p><code>shared_ptr&lt;T&gt;( r, static_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
2861 </dd>
2862 </dl>
2863 </div>
2864 </li>
2865 </ul>
2866 </div>
2867 <div class="admonitionblock caution">
2868 <table>
2869 <tr>
2870 <td class="icon">
2871 <div class="title">Caution</div>
2872 </td>
2873 <td class="content">
2874 The seemingly equivalent expression <code>shared_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code> will eventually
2875 result in undefined behavior, attempting to delete the same object twice.
2876 </td>
2877 </tr>
2878 </table>
2879 </div>
2880 </div>
2881 <div class="sect3">
2882 <h4 id="shared_ptr_const_pointer_cast">const_pointer_cast</h4>
2883 <div class="listingblock">
2884 <div class="content">
2885 <pre class="highlight"><code>template&lt;class T, class U&gt;
2886   shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
2887 </div>
2888 </div>
2889 <div class="ulist none">
2890 <ul class="none">
2891 <li>
2892 <p></p>
2893 <div class="dlist">
2894 <dl>
2895 <dt class="hdlist1">Requires</dt>
2896 <dd>
2897 <p>The expression <code>const_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
2898 </dd>
2899 <dt class="hdlist1">Returns</dt>
2900 <dd>
2901 <p><code>shared_ptr&lt;T&gt;( r, const_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
2902 </dd>
2903 </dl>
2904 </div>
2905 </li>
2906 </ul>
2907 </div>
2908 </div>
2909 <div class="sect3">
2910 <h4 id="shared_ptr_dynamic_pointer_cast">dynamic_pointer_cast</h4>
2911 <div class="listingblock">
2912 <div class="content">
2913 <pre class="highlight"><code>template&lt;class T, class U&gt;
2914     shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
2915 </div>
2916 </div>
2917 <div class="ulist none">
2918 <ul class="none">
2919 <li>
2920 <p></p>
2921 <div class="dlist">
2922 <dl>
2923 <dt class="hdlist1">Requires</dt>
2924 <dd>
2925 <p>The expression <code>dynamic_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
2926 </dd>
2927 <dt class="hdlist1">Returns</dt>
2928 <dd>
2929 <div class="ulist">
2930 <ul>
2931 <li>
2932 <p>When <code>dynamic_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get())</code> returns a nonzero value <code>p</code>, <code>shared_ptr&lt;T&gt;(r, p)</code>;</p>
2933 </li>
2934 <li>
2935 <p>Otherwise, <code>shared_ptr&lt;T&gt;()</code>.</p>
2936 </li>
2937 </ul>
2938 </div>
2939 </dd>
2940 </dl>
2941 </div>
2942 </li>
2943 </ul>
2944 </div>
2945 </div>
2946 <div class="sect3">
2947 <h4 id="shared_ptr_reinterpret_pointer_cast">reinterpret_pointer_cast</h4>
2948 <div class="listingblock">
2949 <div class="content">
2950 <pre class="highlight"><code>template&lt;class T, class U&gt;
2951   shared_ptr&lt;T&gt; reinterpret_pointer_cast(shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
2952 </div>
2953 </div>
2954 <div class="ulist none">
2955 <ul class="none">
2956 <li>
2957 <p></p>
2958 <div class="dlist">
2959 <dl>
2960 <dt class="hdlist1">Requires</dt>
2961 <dd>
2962 <p>The expression <code>reinterpret_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
2963 </dd>
2964 <dt class="hdlist1">Returns</dt>
2965 <dd>
2966 <p><code>shared_ptr&lt;T&gt;( r, reinterpret_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
2967 </dd>
2968 </dl>
2969 </div>
2970 </li>
2971 </ul>
2972 </div>
2973 </div>
2974 <div class="sect3">
2975 <h4 id="shared_ptr_operator">operator&lt;&lt;</h4>
2976 <div class="listingblock">
2977 <div class="content">
2978 <pre class="highlight"><code>template&lt;class E, class T, class Y&gt;
2979   std::basic_ostream&lt;E, T&gt; &amp;
2980     operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, shared_ptr&lt;Y&gt; const &amp; p);</code></pre>
2981 </div>
2982 </div>
2983 <div class="ulist none">
2984 <ul class="none">
2985 <li>
2986 <p></p>
2987 <div class="dlist">
2988 <dl>
2989 <dt class="hdlist1">Effects</dt>
2990 <dd>
2991 <p><code>os &lt;&lt; p.get();</code>.</p>
2992 </dd>
2993 <dt class="hdlist1">Returns</dt>
2994 <dd>
2995 <p><code>os</code>.</p>
2996 </dd>
2997 </dl>
2998 </div>
2999 </li>
3000 </ul>
3001 </div>
3002 </div>
3003 <div class="sect3">
3004 <h4 id="shared_ptr_get_deleter">get_deleter</h4>
3005 <div class="listingblock">
3006 <div class="content">
3007 <pre class="highlight"><code>template&lt;class D, class T&gt;
3008   D * get_deleter(shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
3009 </div>
3010 </div>
3011 <div class="ulist none">
3012 <ul class="none">
3013 <li>
3014 <p></p>
3015 <div class="dlist">
3016 <dl>
3017 <dt class="hdlist1">Returns</dt>
3018 <dd>
3019 <p>If <code>*this</code> owns a deleter <code>d</code> of type (cv-unqualified) <code>D</code>, returns <code>&amp;d</code>; otherwise returns 0.</p>
3020 </dd>
3021 </dl>
3022 </div>
3023 </li>
3024 </ul>
3025 </div>
3026 </div>
3027 <div class="sect3">
3028 <h4 id="shared_ptr_atomic_access">Atomic Access</h4>
3029 <div class="admonitionblock note">
3030 <table>
3031 <tr>
3032 <td class="icon">
3033 <div class="title">Note</div>
3034 </td>
3035 <td class="content">
3036 The function in this section are atomic with respect to the first <code>shared_ptr</code> argument,
3037   identified by <code>*p</code>. Concurrent access to the same <code>shared_ptr</code> instance is not a data race, if
3038   done exclusively by the functions in this section.
3039 </td>
3040 </tr>
3041 </table>
3042 </div>
3043 <div class="listingblock">
3044 <div class="content">
3045 <pre class="highlight"><code>template&lt;class T&gt; bool atomic_is_lock_free( shared_ptr&lt;T&gt; const * p ) noexcept;</code></pre>
3046 </div>
3047 </div>
3048 <div class="ulist none">
3049 <ul class="none">
3050 <li>
3051 <p></p>
3052 <div class="dlist">
3053 <dl>
3054 <dt class="hdlist1">Returns</dt>
3055 <dd>
3056 <p><code>false</code>.</p>
3057 </dd>
3058 </dl>
3059 </div>
3060 </li>
3061 </ul>
3062 </div>
3063 <div class="admonitionblock note">
3064 <table>
3065 <tr>
3066 <td class="icon">
3067 <div class="title">Note</div>
3068 </td>
3069 <td class="content">
3070 This implementation is not lock-free.
3071 </td>
3072 </tr>
3073 </table>
3074 </div>
3075 <div class="listingblock">
3076 <div class="content">
3077 <pre class="highlight"><code>template&lt;class T&gt; shared_ptr&lt;T&gt; atomic_load( shared_ptr&lt;T&gt; const * p ) noexcept;</code></pre>
3078 </div>
3079 </div>
3080 <div class="listingblock">
3081 <div class="content">
3082 <pre class="highlight"><code>template&lt;class T&gt; shared_ptr&lt;T&gt; atomic_load_explicit( shared_ptr&lt;T&gt; const * p, int ) noexcept;</code></pre>
3083 </div>
3084 </div>
3085 <div class="ulist none">
3086 <ul class="none">
3087 <li>
3088 <p></p>
3089 <div class="dlist">
3090 <dl>
3091 <dt class="hdlist1">Returns</dt>
3092 <dd>
3093 <p><code>*p</code>.</p>
3094 </dd>
3095 </dl>
3096 </div>
3097 </li>
3098 </ul>
3099 </div>
3100 <div class="admonitionblock note">
3101 <table>
3102 <tr>
3103 <td class="icon">
3104 <div class="title">Note</div>
3105 </td>
3106 <td class="content">
3107 The <code>int</code> argument is the <code>memory_order</code>, but this implementation does not use it, as it&#8217;s lock-based
3108   and therefore always sequentially consistent.
3109 </td>
3110 </tr>
3111 </table>
3112 </div>
3113 <div class="listingblock">
3114 <div class="content">
3115 <pre class="highlight"><code>template&lt;class T&gt;
3116   void atomic_store( shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r ) noexcept;</code></pre>
3117 </div>
3118 </div>
3119 <div class="listingblock">
3120 <div class="content">
3121 <pre class="highlight"><code>template&lt;class T&gt;
3122   void atomic_store_explicit( shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r, int ) noexcept;</code></pre>
3123 </div>
3124 </div>
3125 <div class="ulist none">
3126 <ul class="none">
3127 <li>
3128 <p></p>
3129 <div class="dlist">
3130 <dl>
3131 <dt class="hdlist1">Effects</dt>
3132 <dd>
3133 <p><code>p-&gt;swap(r)</code>.</p>
3134 </dd>
3135 </dl>
3136 </div>
3137 </li>
3138 </ul>
3139 </div>
3140 <div class="listingblock">
3141 <div class="content">
3142 <pre class="highlight"><code>template&lt;class T&gt;
3143   shared_ptr&lt;T&gt; atomic_exchange( shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r ) noexcept;</code></pre>
3144 </div>
3145 </div>
3146 <div class="listingblock">
3147 <div class="content">
3148 <pre class="highlight"><code>template&lt;class T&gt;
3149   shared_ptr&lt;T&gt; atomic_exchange_explicit(
3150     shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; r, int ) noexcept;</code></pre>
3151 </div>
3152 </div>
3153 <div class="ulist none">
3154 <ul class="none">
3155 <li>
3156 <p></p>
3157 <div class="dlist">
3158 <dl>
3159 <dt class="hdlist1">Effects</dt>
3160 <dd>
3161 <p><code>p-&gt;swap(r)</code>.</p>
3162 </dd>
3163 <dt class="hdlist1">Returns</dt>
3164 <dd>
3165 <p>The old value of <code>*p</code>.</p>
3166 </dd>
3167 </dl>
3168 </div>
3169 </li>
3170 </ul>
3171 </div>
3172 <div class="listingblock">
3173 <div class="content">
3174 <pre class="highlight"><code>template&lt;class T&gt;
3175   bool atomic_compare_exchange(
3176     shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; * v, shared_ptr&lt;T&gt; w ) noexcept;</code></pre>
3177 </div>
3178 </div>
3179 <div class="listingblock">
3180 <div class="content">
3181 <pre class="highlight"><code>template&lt;class T&gt;
3182   bool atomic_compare_exchange_explicit(
3183     shared_ptr&lt;T&gt; * p, shared_ptr&lt;T&gt; * v, shared_ptr&lt;T&gt; w, int, int ) noexcept;</code></pre>
3184 </div>
3185 </div>
3186 <div class="ulist none">
3187 <ul class="none">
3188 <li>
3189 <p></p>
3190 <div class="dlist">
3191 <dl>
3192 <dt class="hdlist1">Effects</dt>
3193 <dd>
3194 <p>If <code>*p</code> is equivalent to <code>*v</code>, assigns <code>w</code> to <code>*p</code>, otherwise assigns <code>*p</code> to <code>*v</code>.</p>
3195 </dd>
3196 <dt class="hdlist1">Returns</dt>
3197 <dd>
3198 <p><code>true</code> if <code>*p</code> was equivalent to <code>*v</code>, <code>false</code> otherwise.</p>
3199 </dd>
3200 <dt class="hdlist1">Remarks</dt>
3201 <dd>
3202 <p>Two <code>shared_ptr</code> instances are equivalent if they store the same pointer value and <em>share ownership</em>.</p>
3203 </dd>
3204 </dl>
3205 </div>
3206 </li>
3207 </ul>
3208 </div>
3209 </div>
3210 </div>
3211 <div class="sect2">
3212 <h3 id="shared_ptr_example">Example</h3>
3213 <div class="paragraph">
3214 <p>See <a href="../../example/shared_ptr_example.cpp">shared_ptr_example.cpp</a> for a complete example program. The program builds a
3215 <code>std::vector</code> and <code>std::set</code> of <code>shared_ptr</code> objects.</p>
3216 </div>
3217 <div class="paragraph">
3218 <p>Note that after the containers have been populated, some of the <code>shared_ptr</code> objects will have a use count of 1 rather than
3219 a use count of 2, since the set is a <code>std::set</code> rather than a <code>std::multiset</code>, and thus does not contain duplicate entries.
3220 Furthermore, the use count may be even higher at various times while <code>push_back</code> and <code>insert</code> container operations are performed.
3221 More complicated yet, the container operations may throw exceptions under a variety of circumstances. Getting the memory management
3222 and exception handling in this example right without a smart pointer would be a nightmare.</p>
3223 </div>
3224 </div>
3225 <div class="sect2">
3226 <h3 id="shared_ptr_handlebody_idiom">Handle/Body Idiom</h3>
3227 <div class="paragraph">
3228 <p>One common usage of <code>shared_ptr</code> is to implement a handle/body (also called pimpl) idiom which avoids exposing the body (implementation)
3229 in the header file.</p>
3230 </div>
3231 <div class="paragraph">
3232 <p>The <a href="../../example/shared_ptr_example2_test.cpp">shared_ptr_example2_test.cpp</a> sample program includes a header file,
3233 <a href="../../example/shared_ptr_example2.hpp">shared_ptr_example2.hpp</a>, which uses a <code>shared_ptr</code> to an incomplete type to hide the implementation.
3234 The instantiation of member functions which require a complete type occurs in the <a href="../../example/shared_ptr_example2.cpp">shared_ptr_example2.cpp</a>
3235 implementation file. Note that there is no need for an explicit destructor. Unlike <code>~scoped_ptr</code>, <code>~shared_ptr</code> does not require that <code>T</code> be a complete type.</p>
3236 </div>
3237 </div>
3238 <div class="sect2">
3239 <h3 id="shared_ptr_thread_safety">Thread Safety</h3>
3240 <div class="paragraph">
3241 <p><code>shared_ptr</code> objects offer the same level of thread safety as built-in types. A <code>shared_ptr</code> instance can be "read" (accessed using only const operations)
3242 simultaneously by multiple threads. Different <code>shared_ptr</code> instances can be "written to" (accessed using mutable operations such as <code>operator=</code> or <code>reset</code>)
3243 simultaneously by multiple threads (even when these instances are copies, and share the same reference count underneath.)</p>
3244 </div>
3245 <div class="paragraph">
3246 <p>Any other simultaneous accesses result in undefined behavior.</p>
3247 </div>
3248 <div class="paragraph">
3249 <p>Examples:</p>
3250 </div>
3251 <div class="listingblock">
3252 <div class="content">
3253 <pre class="highlight"><code>shared_ptr&lt;int&gt; p(new int(42));</code></pre>
3254 </div>
3255 </div>
3256 <div class="listingblock">
3257 <div class="title">Code Example 4. Reading a <code>shared_ptr</code> from two threads</div>
3258 <div class="content">
3259 <pre class="highlight"><code>// thread A
3260 shared_ptr&lt;int&gt; p2(p); // reads p
3261
3262 // thread B
3263 shared_ptr&lt;int&gt; p3(p); // OK, multiple reads are safe</code></pre>
3264 </div>
3265 </div>
3266 <div class="listingblock">
3267 <div class="title">Code Example 5. Writing different <code>shared_ptr</code> instances from two threads</div>
3268 <div class="content">
3269 <pre class="highlight"><code>// thread A
3270 p.reset(new int(1912)); // writes p
3271
3272 // thread B
3273 p2.reset(); // OK, writes p2</code></pre>
3274 </div>
3275 </div>
3276 <div class="listingblock">
3277 <div class="title">Code Example 6. Reading and writing a <code>shared_ptr</code> from two threads</div>
3278 <div class="content">
3279 <pre class="highlight"><code>// thread A
3280 p = p3; // reads p3, writes p
3281
3282 // thread B
3283 p3.reset(); // writes p3; undefined, simultaneous read/write</code></pre>
3284 </div>
3285 </div>
3286 <div class="listingblock">
3287 <div class="title">Code Example 7. Reading and destroying a <code>shared_ptr</code> from two threads</div>
3288 <div class="content">
3289 <pre class="highlight"><code>// thread A
3290 p3 = p2; // reads p2, writes p3
3291
3292 // thread B
3293 // p2 goes out of scope: undefined, the destructor is considered a "write access"</code></pre>
3294 </div>
3295 </div>
3296 <div class="listingblock">
3297 <div class="title">Code Example 8. Writing a <code>shared_ptr</code> from two threads</div>
3298 <div class="content">
3299 <pre class="highlight"><code>// thread A
3300 p3.reset(new int(1));
3301
3302 // thread B
3303 p3.reset(new int(2)); // undefined, multiple writes</code></pre>
3304 </div>
3305 </div>
3306 <div class="paragraph">
3307 <p>Starting with Boost release 1.33.0, <code>shared_ptr</code> uses a lock-free implementation on most common platforms.</p>
3308 </div>
3309 <div class="paragraph">
3310 <p>If your program is single-threaded and does not link to any libraries that might have used <code>shared_ptr</code> in its default configuration,
3311 you can <code>#define</code> the macro <code>BOOST_SP_DISABLE_THREADS</code> on a project-wide basis to switch to ordinary non-atomic reference count updates.</p>
3312 </div>
3313 <div class="paragraph">
3314 <p>(Defining <code>BOOST_SP_DISABLE_THREADS</code> in some, but not all, translation units is technically a violation of the One Definition Rule and
3315 undefined behavior. Nevertheless, the implementation attempts to do its best to accommodate the request to use non-atomic updates in those
3316 translation units. No guarantees, though.)</p>
3317 </div>
3318 <div class="paragraph">
3319 <p>You can define the macro <code>BOOST_SP_USE_PTHREADS</code> to turn off the lock-free platform-specific implementation and fall back to the generic
3320 <code>pthread_mutex_t</code>-based code.</p>
3321 </div>
3322 </div>
3323 <div class="sect2">
3324 <h3 id="shared_ptr_frequently_asked_questions">Frequently Asked Questions</h3>
3325 <div class="qlist qanda">
3326 <ol>
3327 <li>
3328 <p><em>There are several variations of shared pointers, with different tradeoffs; why does the smart pointer library supply only a single implementation? It would be useful to be able to experiment with each type so as to find the most suitable for the job at hand?</em></p>
3329 <p>An important goal of <code>shared_ptr</code> is to provide a standard shared-ownership pointer. Having a single pointer type is important for stable
3330 library interfaces, since different shared pointers typically cannot interoperate, i.e. a reference counted pointer (used by library A)
3331 cannot share ownership with a linked pointer (used by library B.)</p>
3332 </li>
3333 <li>
3334 <p><em>Why doesn&#8217;t shared_ptr have template parameters supplying traits or policies to allow extensive user customization?</em></p>
3335 <p>Parameterization discourages users. The <code>shared_ptr</code> template is carefully crafted to meet common needs without extensive parameterization.</p>
3336 </li>
3337 <li>
3338 <p><em>I am not convinced. Default parameters can be used where appropriate to hide the complexity. Again, why not policies?</em></p>
3339 <p>Template parameters affect the type. See the answer to the first question above.</p>
3340 </li>
3341 <li>
3342 <p><em>Why doesn&#8217;t <code>shared_ptr</code> use a linked list implementation?</em></p>
3343 <p>A linked list implementation does not offer enough advantages to offset the added cost of an extra pointer. In addition, it is expensive to
3344 make a linked list implementation thread safe.</p>
3345 </li>
3346 <li>
3347 <p><em>Why doesn&#8217;t <code>shared_ptr</code> (or any of the other Boost smart pointers) supply an automatic conversion to T*?</em></p>
3348 <p>Automatic conversion is believed to be too error prone.</p>
3349 </li>
3350 <li>
3351 <p><em>Why does <code>shared_ptr</code> supply <code>use_count()</code>?</em></p>
3352 <p>As an aid to writing test cases and debugging displays. One of the progenitors had <code>use_count()</code>, and it was useful in tracking down bugs in
3353 a complex project that turned out to have cyclic-dependencies.</p>
3354 </li>
3355 <li>
3356 <p><em>Why doesn&#8217;t <code>shared_ptr</code> specify complexity requirements?</em></p>
3357 <p>Because complexity requirements limit implementors and complicate the specification without apparent benefit to <code>shared_ptr</code> users. For example,
3358 error-checking implementations might become non-conforming if they had to meet stringent complexity requirements.</p>
3359 </li>
3360 <li>
3361 <p><em>Why doesn&#8217;t <code>shared_ptr</code> provide a <code>release()</code> function?</em></p>
3362 <p><code>shared_ptr</code> cannot give away ownership unless it&#8217;s <code>unique()</code> because the other copy will still destroy the object.</p>
3363 <div class="paragraph">
3364 <p>Consider:</p>
3365 </div>
3366 <div class="listingblock">
3367 <div class="content">
3368 <pre class="highlight"><code>shared_ptr&lt;int&gt; a(new int);
3369 shared_ptr&lt;int&gt; b(a); // a.use_count() == b.use_count() == 2
3370
3371 int * p = a.release();
3372
3373 // Who owns p now? b will still call delete on it in its destructor.</code></pre>
3374 </div>
3375 </div>
3376 <div class="paragraph">
3377 <p>Furthermore, the pointer returned by <code>release()</code> would be difficult to deallocate reliably, as the source <code>shared_ptr</code> could have been created with a
3378 custom deleter, or may have pointed to an object of a different type.</p>
3379 </div>
3380 </li>
3381 <li>
3382 <p><em>Why is <code>operator-&gt;()</code> const, but its return value is a non-const pointer to the element type?</em></p>
3383 <p>Shallow copy pointers, including raw pointers, typically don&#8217;t propagate constness. It makes little sense for them to do so, as you can always obtain a
3384 non-const pointer from a const one and then proceed to modify the object through it. <code>shared_ptr</code> is "as close to raw pointers as possible but no closer".</p>
3385 </li>
3386 </ol>
3387 </div>
3388 </div>
3389 </div>
3390 </div>
3391 <div class="sect1">
3392 <h2 id="weak_ptr">weak_ptr: Non-owning Observer</h2>
3393 <div class="sectionbody">
3394 <div class="sect2">
3395 <h3 id="weak_ptr_description">Description</h3>
3396 <div class="paragraph">
3397 <p>The <code>weak_ptr</code> class template stores a "weak reference" to an object that&#8217;s already managed by a <code>shared_ptr</code>.
3398 To access the object, a <code>weak_ptr</code> can be converted to a <code>shared_ptr</code> using the <code>shared_ptr</code> constructor taking
3399 <code>weak_ptr</code>, or the <code>weak_ptr</code> member function <code>lock</code>. When the last <code>shared_ptr</code> to the object goes away and the
3400 object is deleted, the attempt to obtain a <code>shared_ptr</code> from the <code>weak_ptr</code> instances that refer to the deleted
3401 object will fail: the constructor will throw an exception of type <code>boost::bad_weak_ptr</code>, and <code>weak_ptr::lock</code> will
3402 return an empty <code>shared_ptr</code>.</p>
3403 </div>
3404 <div class="paragraph">
3405 <p>Every <code>weak_ptr</code> meets the <code>CopyConstructible</code> and <code>Assignable</code> requirements of the C&#43;&#43; Standard Library, and so
3406 can be used in standard library containers. Comparison operators are supplied so that <code>weak_ptr</code> works with the standard
3407 library&#8217;s associative containers.</p>
3408 </div>
3409 <div class="paragraph">
3410 <p><code>weak_ptr</code> operations never throw exceptions.</p>
3411 </div>
3412 <div class="paragraph">
3413 <p>The class template is parameterized on <code>T</code>, the type of the object pointed to.</p>
3414 </div>
3415 <div class="paragraph">
3416 <p>Compared to <code>shared_ptr</code>, <code>weak_ptr</code> provides a very limited subset of operations since accessing its stored pointer is
3417 often dangerous in multithreaded programs, and sometimes unsafe even within a single thread (that is, it may invoke undefined
3418 behavior.) Pretend for a moment that <code>weak_ptr</code> had a get member function that returned a raw pointer, and consider this innocent
3419 piece of code:</p>
3420 </div>
3421 <div class="listingblock">
3422 <div class="content">
3423 <pre class="highlight"><code>shared_ptr&lt;int&gt; p(new int(5));
3424 weak_ptr&lt;int&gt; q(p);
3425
3426 // some time later
3427
3428 if(int * r = q.get())
3429 {
3430     // use *r
3431 }</code></pre>
3432 </div>
3433 </div>
3434 <div class="paragraph">
3435 <p>Imagine that after the <code>if</code>, but immediately before <code>r</code> is used, another thread executes the statement <code>p.reset()</code>. Now <code>r</code> is a dangling pointer.</p>
3436 </div>
3437 <div class="paragraph">
3438 <p>The solution to this problem is to create a temporary <code>shared_ptr</code> from <code>q</code>:</p>
3439 </div>
3440 <div class="listingblock">
3441 <div class="content">
3442 <pre class="highlight"><code>shared_ptr&lt;int&gt; p(new int(5));
3443 weak_ptr&lt;int&gt; q(p);
3444
3445 // some time later
3446
3447 if(shared_ptr&lt;int&gt; r = q.lock())
3448 {
3449     // use *r
3450 }</code></pre>
3451 </div>
3452 </div>
3453 <div class="paragraph">
3454 <p>Now <code>r</code> holds a reference to the object that was pointed by <code>q</code>. Even if <code>p.reset()</code> is executed in another thread, the object will stay alive until
3455 <code>r</code> goes out of scope or is reset. By obtaining a <code>shared_ptr</code> to the object, we have effectively locked it against destruction.</p>
3456 </div>
3457 </div>
3458 <div class="sect2">
3459 <h3 id="weak_ptr_synopsis">Synopsis</h3>
3460 <div class="paragraph">
3461 <p><code>weak_ptr</code> is defined in <code>&lt;boost/smart_ptr/weak_ptr.hpp&gt;</code>.</p>
3462 </div>
3463 <div class="listingblock">
3464 <div class="content">
3465 <pre class="highlight"><code>namespace boost {
3466
3467   template&lt;class T&gt; class weak_ptr {
3468   public:
3469
3470     typedef /*see below*/ element_type;
3471
3472     weak_ptr() noexcept;
3473
3474     template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const &amp; r) noexcept;
3475     weak_ptr(weak_ptr const &amp; r) noexcept;
3476     template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const &amp; r) noexcept;
3477
3478     weak_ptr(weak_ptr &amp;&amp; r) noexcept;
3479
3480     template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;
3481     template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;
3482     template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;
3483
3484     ~weak_ptr() noexcept;
3485
3486     weak_ptr &amp; operator=(weak_ptr const &amp; r) noexcept;
3487     weak_ptr &amp; operator=(weak_ptr &amp;&amp; r) noexcept;
3488     template&lt;class Y&gt; weak_ptr &amp; operator=(weak_ptr&lt;Y&gt; const &amp; r) noexcept;
3489     template&lt;class Y&gt; weak_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r) noexcept;
3490
3491     long use_count() const noexcept;
3492     bool expired() const noexcept;
3493
3494     bool empty() const noexcept;
3495
3496     shared_ptr&lt;T&gt; lock() const noexcept;
3497
3498     void reset() noexcept;
3499
3500     void swap(weak_ptr&lt;T&gt; &amp; b) noexcept;
3501
3502     template&lt;class Y&gt; bool owner_before( weak_ptr&lt;Y&gt; const &amp; r ) const noexcept;
3503     template&lt;class Y&gt; bool owner_before( shared_ptr&lt;Y&gt; const &amp; r ) const noexcept;
3504   };
3505
3506   template&lt;class T, class U&gt;
3507     bool operator&lt;(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b) noexcept;
3508
3509   template&lt;class T&gt; void swap(weak_ptr&lt;T&gt; &amp; a, weak_ptr&lt;T&gt; &amp; b) noexcept;
3510 }</code></pre>
3511 </div>
3512 </div>
3513 </div>
3514 <div class="sect2">
3515 <h3 id="weak_ptr_members">Members</h3>
3516 <div class="sect3">
3517 <h4 id="weak_ptr_element_type">element_type</h4>
3518 <div class="listingblock">
3519 <div class="content">
3520 <pre class="highlight"><code>typedef ... element_type;</code></pre>
3521 </div>
3522 </div>
3523 <div class="paragraph">
3524 <p><code>element_type</code> is <code>T</code> when <code>T</code> is not an array type, and <code>U</code> when <code>T</code> is <code>U[]</code> or <code>U[N]</code>.</p>
3525 </div>
3526 </div>
3527 <div class="sect3">
3528 <h4 id="weak_ptr_constructors">constructors</h4>
3529 <div class="listingblock">
3530 <div class="content">
3531 <pre class="highlight"><code>weak_ptr() noexcept;</code></pre>
3532 </div>
3533 </div>
3534 <div class="ulist none">
3535 <ul class="none">
3536 <li>
3537 <p></p>
3538 <div class="dlist">
3539 <dl>
3540 <dt class="hdlist1">Effects</dt>
3541 <dd>
3542 <p>Constructs an empty <code>weak_ptr</code>.</p>
3543 </dd>
3544 <dt class="hdlist1">Postconditions</dt>
3545 <dd>
3546 <p><code>use_count() == 0</code>.</p>
3547 </dd>
3548 </dl>
3549 </div>
3550 </li>
3551 </ul>
3552 </div>
3553 <div class="listingblock">
3554 <div class="content">
3555 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
3556 </div>
3557 </div>
3558 <div class="listingblock">
3559 <div class="content">
3560 <pre class="highlight"><code>weak_ptr(weak_ptr const &amp; r) noexcept;</code></pre>
3561 </div>
3562 </div>
3563 <div class="listingblock">
3564 <div class="content">
3565 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
3566 </div>
3567 </div>
3568 <div class="ulist none">
3569 <ul class="none">
3570 <li>
3571 <p></p>
3572 <div class="dlist">
3573 <dl>
3574 <dt class="hdlist1">Effects</dt>
3575 <dd>
3576 <p>If <code>r</code> is empty, constructs an empty <code>weak_ptr</code>; otherwise, constructs a <code>weak_ptr</code> that shares ownership with <code>r</code> as if by storing a copy of the pointer stored in <code>r</code>.</p>
3577 </dd>
3578 <dt class="hdlist1">Postconditions</dt>
3579 <dd>
3580 <p><code>use_count() == r.use_count()</code>.</p>
3581 </dd>
3582 </dl>
3583 </div>
3584 </li>
3585 </ul>
3586 </div>
3587 <div class="listingblock">
3588 <div class="content">
3589 <pre class="highlight"><code>weak_ptr(weak_ptr &amp;&amp; r) noexcept;</code></pre>
3590 </div>
3591 </div>
3592 <div class="ulist none">
3593 <ul class="none">
3594 <li>
3595 <p></p>
3596 <div class="dlist">
3597 <dl>
3598 <dt class="hdlist1">Effects</dt>
3599 <dd>
3600 <p>Constructs a <code>weak_ptr</code> that has the value <code>r</code> held.</p>
3601 </dd>
3602 <dt class="hdlist1">Postconditions</dt>
3603 <dd>
3604 <p><code>r</code> is empty.</p>
3605 </dd>
3606 </dl>
3607 </div>
3608 </li>
3609 </ul>
3610 </div>
3611 </div>
3612 <div class="sect3">
3613 <h4 id="weak_ptr_aliasing_constructors">aliasing constructors</h4>
3614 <div class="listingblock">
3615 <div class="content">
3616 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;</code></pre>
3617 </div>
3618 </div>
3619 <div class="listingblock">
3620 <div class="content">
3621 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;</code></pre>
3622 </div>
3623 </div>
3624 <div class="listingblock">
3625 <div class="content">
3626 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;</code></pre>
3627 </div>
3628 </div>
3629 <div class="dlist">
3630 <dl>
3631 <dt class="hdlist1">Effects</dt>
3632 <dd>
3633 <p>Constructs a <code>weak_ptr</code> from <code>r</code> as if by using the corresponding converting/copy/move constructor, but stores <code>p</code> instead.</p>
3634 </dd>
3635 <dt class="hdlist1">Postconditions</dt>
3636 <dd>
3637 <p><code>use_count() == r.use_count()</code>. When <code>!expired()</code>, <code>shared_ptr&lt;T&gt;(*this).get() == p</code>.</p>
3638 </dd>
3639 </dl>
3640 </div>
3641 <div class="admonitionblock note">
3642 <table>
3643 <tr>
3644 <td class="icon">
3645 <div class="title">Note</div>
3646 </td>
3647 <td class="content">
3648 These constructors are an extension, not present in <code>std::weak_ptr</code>.
3649 </td>
3650 </tr>
3651 </table>
3652 </div>
3653 </div>
3654 <div class="sect3">
3655 <h4 id="weak_ptr_destructor">destructor</h4>
3656 <div class="listingblock">
3657 <div class="content">
3658 <pre class="highlight"><code>~weak_ptr() noexcept;</code></pre>
3659 </div>
3660 </div>
3661 <div class="ulist none">
3662 <ul class="none">
3663 <li>
3664 <p></p>
3665 <div class="dlist">
3666 <dl>
3667 <dt class="hdlist1">Effects</dt>
3668 <dd>
3669 <p>Destroys this <code>weak_ptr</code> but has no effect on the object its stored pointer points to.</p>
3670 </dd>
3671 </dl>
3672 </div>
3673 </li>
3674 </ul>
3675 </div>
3676 </div>
3677 <div class="sect3">
3678 <h4 id="weak_ptr_assignment">assignment</h4>
3679 <div class="listingblock">
3680 <div class="content">
3681 <pre class="highlight"><code>weak_ptr &amp; operator=(weak_ptr const &amp; r) noexcept;</code></pre>
3682 </div>
3683 </div>
3684 <div class="listingblock">
3685 <div class="content">
3686 <pre class="highlight"><code>weak_ptr &amp; operator=(weak_ptr &amp;&amp; r) noexcept;</code></pre>
3687 </div>
3688 </div>
3689 <div class="listingblock">
3690 <div class="content">
3691 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr &amp; operator=(weak_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
3692 </div>
3693 </div>
3694 <div class="listingblock">
3695 <div class="content">
3696 <pre class="highlight"><code>template&lt;class Y&gt; weak_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
3697 </div>
3698 </div>
3699 <div class="ulist none">
3700 <ul class="none">
3701 <li>
3702 <p></p>
3703 <div class="dlist">
3704 <dl>
3705 <dt class="hdlist1">Effects</dt>
3706 <dd>
3707 <p>Equivalent to <code>weak_ptr(r).swap(*this)</code>.</p>
3708 </dd>
3709 </dl>
3710 </div>
3711 </li>
3712 </ul>
3713 </div>
3714 <div class="admonitionblock note">
3715 <table>
3716 <tr>
3717 <td class="icon">
3718 <div class="title">Note</div>
3719 </td>
3720 <td class="content">
3721 The implementation is free to meet the effects (and the implied guarantees) via different means, without creating a temporary.
3722 </td>
3723 </tr>
3724 </table>
3725 </div>
3726 </div>
3727 <div class="sect3">
3728 <h4 id="weak_ptr_use_count">use_count</h4>
3729 <div class="listingblock">
3730 <div class="content">
3731 <pre class="highlight"><code>long use_count() const noexcept;</code></pre>
3732 </div>
3733 </div>
3734 <div class="ulist none">
3735 <ul class="none">
3736 <li>
3737 <p></p>
3738 <div class="dlist">
3739 <dl>
3740 <dt class="hdlist1">Returns</dt>
3741 <dd>
3742 <p>0 if <code>*this</code> is empty; otherwise, the number of <code>shared_ptr</code> objects that share ownership with <code>*this</code>.</p>
3743 </dd>
3744 </dl>
3745 </div>
3746 </li>
3747 </ul>
3748 </div>
3749 </div>
3750 <div class="sect3">
3751 <h4 id="weak_ptr_expired">expired</h4>
3752 <div class="listingblock">
3753 <div class="content">
3754 <pre class="highlight"><code>bool expired() const noexcept;</code></pre>
3755 </div>
3756 </div>
3757 <div class="ulist none">
3758 <ul class="none">
3759 <li>
3760 <p></p>
3761 <div class="dlist">
3762 <dl>
3763 <dt class="hdlist1">Returns</dt>
3764 <dd>
3765 <p><code>use_count() == 0</code>.</p>
3766 </dd>
3767 </dl>
3768 </div>
3769 </li>
3770 </ul>
3771 </div>
3772 </div>
3773 <div class="sect3">
3774 <h4 id="weak_ptr_empty">empty</h4>
3775 <div class="listingblock">
3776 <div class="content">
3777 <pre class="highlight"><code>bool empty() const noexcept;</code></pre>
3778 </div>
3779 </div>
3780 <div class="ulist none">
3781 <ul class="none">
3782 <li>
3783 <p></p>
3784 <div class="dlist">
3785 <dl>
3786 <dt class="hdlist1">Returns</dt>
3787 <dd>
3788 <p><code>true</code> when <code>*this</code> is empty, <code>false</code> otherwise.</p>
3789 </dd>
3790 </dl>
3791 </div>
3792 </li>
3793 </ul>
3794 </div>
3795 <div class="admonitionblock note">
3796 <table>
3797 <tr>
3798 <td class="icon">
3799 <div class="title">Note</div>
3800 </td>
3801 <td class="content">
3802 This function is an extension, not present in <code>std::weak_ptr</code>.
3803 </td>
3804 </tr>
3805 </table>
3806 </div>
3807 </div>
3808 <div class="sect3">
3809 <h4 id="weak_ptr_lock">lock</h4>
3810 <div class="listingblock">
3811 <div class="content">
3812 <pre class="highlight"><code>shared_ptr&lt;T&gt; lock() const noexcept;</code></pre>
3813 </div>
3814 </div>
3815 <div class="ulist none">
3816 <ul class="none">
3817 <li>
3818 <p></p>
3819 <div class="dlist">
3820 <dl>
3821 <dt class="hdlist1">Returns</dt>
3822 <dd>
3823 <p><code>expired()? shared_ptr&lt;T&gt;(): shared_ptr&lt;T&gt;(*this)</code>.</p>
3824 </dd>
3825 </dl>
3826 </div>
3827 </li>
3828 </ul>
3829 </div>
3830 </div>
3831 <div class="sect3">
3832 <h4 id="weak_ptr_reset">reset</h4>
3833 <div class="listingblock">
3834 <div class="content">
3835 <pre class="highlight"><code>void reset() noexcept;</code></pre>
3836 </div>
3837 </div>
3838 <div class="ulist none">
3839 <ul class="none">
3840 <li>
3841 <p></p>
3842 <div class="dlist">
3843 <dl>
3844 <dt class="hdlist1">Effects</dt>
3845 <dd>
3846 <p>Equivalent to <code>weak_ptr().swap(*this)</code>.</p>
3847 </dd>
3848 </dl>
3849 </div>
3850 </li>
3851 </ul>
3852 </div>
3853 </div>
3854 <div class="sect3">
3855 <h4 id="weak_ptr_swap">swap</h4>
3856 <div class="listingblock">
3857 <div class="content">
3858 <pre class="highlight"><code>void swap(weak_ptr &amp; b) noexcept;</code></pre>
3859 </div>
3860 </div>
3861 <div class="ulist none">
3862 <ul class="none">
3863 <li>
3864 <p></p>
3865 <div class="dlist">
3866 <dl>
3867 <dt class="hdlist1">Effects</dt>
3868 <dd>
3869 <p>Exchanges the contents of the two smart pointers.</p>
3870 </dd>
3871 </dl>
3872 </div>
3873 </li>
3874 </ul>
3875 </div>
3876 <div class="listingblock">
3877 <div class="content">
3878 <pre class="highlight"><code>template&lt;class Y&gt; bool owner_before( weak_ptr&lt;Y&gt; const &amp; r ) const noexcept;</code></pre>
3879 </div>
3880 </div>
3881 <div class="listingblock">
3882 <div class="content">
3883 <pre class="highlight"><code>template&lt;class Y&gt; bool owner_before( shared_ptr&lt;Y&gt; const &amp; r ) const noexcept;</code></pre>
3884 </div>
3885 </div>
3886 <div class="ulist none">
3887 <ul class="none">
3888 <li>
3889 <p></p>
3890 <div class="dlist">
3891 <dl>
3892 <dt class="hdlist1">Returns</dt>
3893 <dd>
3894 <p>See the description of <code>operator&lt;</code>.</p>
3895 </dd>
3896 </dl>
3897 </div>
3898 </li>
3899 </ul>
3900 </div>
3901 </div>
3902 </div>
3903 <div class="sect2">
3904 <h3 id="weak_ptr_free_functions">Free Functions</h3>
3905 <div class="sect3">
3906 <h4 id="weak_ptr_comparison">comparison</h4>
3907 <div class="listingblock">
3908 <div class="content">
3909 <pre class="highlight"><code>template&lt;class T, class U&gt;
3910   bool operator&lt;(weak_ptr&lt;T&gt; const &amp; a, weak_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
3911 </div>
3912 </div>
3913 <div class="ulist none">
3914 <ul class="none">
3915 <li>
3916 <p></p>
3917 <div class="dlist">
3918 <dl>
3919 <dt class="hdlist1">Returns</dt>
3920 <dd>
3921 <p>An unspecified value such that</p>
3922 <div class="ulist">
3923 <ul>
3924 <li>
3925 <p><code>operator&lt;</code> is a strict weak ordering as described in section [lib.alg.sorting] of the C&#43;&#43; standard;</p>
3926 </li>
3927 <li>
3928 <p>under the equivalence relation defined by <code>operator&lt;</code>, <code>!(a &lt; b) &amp;&amp; !(b &lt; a)</code>, two <code>weak_ptr</code> instances
3929 are equivalent if and only if they share ownership or are both empty.</p>
3930 </li>
3931 </ul>
3932 </div>
3933 </dd>
3934 </dl>
3935 </div>
3936 </li>
3937 </ul>
3938 </div>
3939 <div class="admonitionblock note">
3940 <table>
3941 <tr>
3942 <td class="icon">
3943 <div class="title">Note</div>
3944 </td>
3945 <td class="content">
3946 Allows <code>weak_ptr</code> objects to be used as keys in associative containers.
3947 </td>
3948 </tr>
3949 </table>
3950 </div>
3951 </div>
3952 <div class="sect3">
3953 <h4 id="weak_ptr_swap_2">swap</h4>
3954 <div class="listingblock">
3955 <div class="content">
3956 <pre class="highlight"><code>template&lt;class T&gt; void swap(weak_ptr&lt;T&gt; &amp; a, weak_ptr&lt;T&gt; &amp; b) noexcept;</code></pre>
3957 </div>
3958 </div>
3959 <div class="ulist none">
3960 <ul class="none">
3961 <li>
3962 <p></p>
3963 <div class="dlist">
3964 <dl>
3965 <dt class="hdlist1">Effects</dt>
3966 <dd>
3967 <p>Equivalent to <code>a.swap(b)</code>.</p>
3968 </dd>
3969 </dl>
3970 </div>
3971 </li>
3972 </ul>
3973 </div>
3974 </div>
3975 </div>
3976 <div class="sect2">
3977 <h3 id="weak_ptr_frequently_asked_questions">Frequently Asked Questions</h3>
3978 <div class="qlist qanda">
3979 <ol>
3980 <li>
3981 <p><em>Can an object create a weak_ptr to itself in its constructor?</em></p>
3982 <p>No. A <code>weak_ptr</code> can only be created from a <code>shared_ptr</code>, and at object construction time no
3983 <code>shared_ptr</code> to the object exists yet. Even if you could create a temporary <code>shared_ptr</code> to <code>this</code>,
3984 it would go out of scope at the end of the constructor, and all <code>weak_ptr</code> instances would instantly expire.</p>
3985 <div class="paragraph">
3986 <p>The solution is to make the constructor private, and supply a factory function that returns a <code>shared_ptr</code>:</p>
3987 </div>
3988 <div class="listingblock">
3989 <div class="content">
3990 <pre class="highlight"><code>class X
3991 {
3992 private:
3993
3994     X();
3995
3996 public:
3997
3998     static shared_ptr&lt;X&gt; create()
3999     {
4000         shared_ptr&lt;X&gt; px(new X);
4001         // create weak pointers from px here
4002         return px;
4003     }
4004 };</code></pre>
4005 </div>
4006 </div>
4007 </li>
4008 </ol>
4009 </div>
4010 </div>
4011 </div>
4012 </div>
4013 <div class="sect1">
4014 <h2 id="make_shared">make_shared: Creating shared_ptr</h2>
4015 <div class="sectionbody">
4016 <div class="sect2">
4017 <h3 id="make_shared_description">Description</h3>
4018 <div class="paragraph">
4019 <p>The function templates <code>make_shared</code> and <code>allocate_shared</code> provide convenient,
4020 safe and efficient ways to create <code>shared_ptr</code> objects.</p>
4021 </div>
4022 </div>
4023 <div class="sect2">
4024 <h3 id="make_shared_rationale">Rationale</h3>
4025 <div class="paragraph">
4026 <p>Consistent use of <code>shared_ptr</code> can eliminate the need to use an explicit
4027 <code>delete</code>, but alone it provides no support in avoiding explicit <code>new</code>. There
4028 were repeated requests from users for a factory function that creates an
4029 object of a given type and returns a <code>shared_ptr</code> to it. Besides convenience
4030 and style, such a function is also exception safe and considerably faster
4031 because it can use a single allocation for both the object and its
4032 corresponding control block, eliminating a significant portion of
4033 <code>shared_ptr</code> construction overhead. This eliminates one of the major
4034 efficiency complaints about <code>shared_ptr</code>.</p>
4035 </div>
4036 <div class="paragraph">
4037 <p>The family of overloaded function templates, <code>make_shared</code> and
4038 <code>allocate_shared</code>, were provided to address this need. <code>make_shared</code> uses the
4039 global <code>operator new</code> to allocate memory, whereas <code>allocate_shared</code> uses an
4040 user-supplied allocator, allowing finer control.</p>
4041 </div>
4042 <div class="paragraph">
4043 <p>The rationale for choosing the name <code>make_shared</code> is that the expression
4044 <code>make_shared&lt;Widget&gt;()</code> can be read aloud and conveys the intended meaning.</p>
4045 </div>
4046 <div class="paragraph">
4047 <p>Originally the Boost function templates <code>allocate_shared</code> and <code>make_shared</code>
4048 were provided for scalar objects only. There was a need to have efficient
4049 allocation of array objects. One criticism of class template <code>shared_array</code>
4050 was always the lack of a utility like <code>make_shared</code> that uses only a single
4051 allocation. When <code>shared_ptr</code> was enhanced to support array types, additional
4052 overloads of <code>allocate_shared</code> and <code>make_shared</code> were provided for array
4053 types.</p>
4054 </div>
4055 </div>
4056 <div class="sect2">
4057 <h3 id="make_shared_synopsis">Synopsis</h3>
4058 <div class="paragraph">
4059 <p><code>make_shared</code> and <code>allocate_shared</code> are defined in
4060 <code>&lt;boost/smart_ptr/make_shared.hpp&gt;</code>.</p>
4061 </div>
4062 <div class="listingblock">
4063 <div class="content">
4064 <pre class="highlight"><code>namespace boost {
4065   <code>// T is not an array</code>
4066   template&lt;class T, class... Args&gt;
4067     shared_ptr&lt;T&gt; make_shared(Args&amp;&amp;... args);
4068   template&lt;class T, class A, class... Args&gt;
4069     shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);
4070
4071   <code>// T is an array of unknown bounds</code>
4072   template&lt;class T&gt;
4073     shared_ptr&lt;T&gt; make_shared(std::size_t n);
4074   template&lt;class T, class A&gt;
4075     shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, std::size_t n);
4076
4077   <code>// T is an array of known bounds</code>
4078   template&lt;class T&gt;
4079     shared_ptr&lt;T&gt; make_shared();
4080   template&lt;class T, class A&gt;
4081     shared_ptr&lt;T&gt; allocate_shared(const A&amp; a);
4082
4083   <code>// T is an array of unknown bounds</code>
4084   template&lt;class T&gt; shared_ptr&lt;T&gt;
4085     make_shared(std::size_t n, const remove_extent_t&lt;T&gt;&amp; v);
4086   template&lt;class T, class A&gt; shared_ptr&lt;T&gt;
4087     allocate_shared(const A&amp; a, std::size_t n, const remove_extent_t&lt;T&gt;&amp; v);
4088
4089   <code>// T is an array of known bounds</code>
4090   template&lt;class T&gt;
4091     shared_ptr&lt;T&gt; make_shared(const remove_extent_t&lt;T&gt;&amp; v);
4092   template&lt;class T, class A&gt;
4093     shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, const remove_extent_t&lt;T&gt;&amp; v);
4094
4095   <code>// T is not an array of unknown bounds</code>
4096   template&lt;class T&gt;
4097     shared_ptr&lt;T&gt; make_shared_noinit();
4098   template&lt;class T, class A&gt;
4099     shared_ptr&lt;T&gt; allocate_shared_noinit(const A&amp; a);
4100
4101   <code>// T is an array of unknown bounds</code>
4102   template&lt;class T&gt;
4103     shared_ptr&lt;T&gt; make_shared_noinit(std::size_t n);
4104   template&lt;class T, class A&gt;
4105     shared_ptr&lt;T&gt; allocate_shared_noinit(const A&amp; a, std::size_t n);
4106 }</code></pre>
4107 </div>
4108 </div>
4109 </div>
4110 <div class="sect2">
4111 <h3 id="make_shared_common_requirements">Common Requirements</h3>
4112 <div class="paragraph">
4113 <p>The common requirements that apply to all <code>make_shared</code> and <code>allocate_shared</code>
4114 overloads, unless specified otherwise, are described below.</p>
4115 </div>
4116 <div class="dlist">
4117 <dl>
4118 <dt class="hdlist1">Requires</dt>
4119 <dd>
4120 <p><code>A</code> shall be an <em>allocator</em>. The copy constructor and destructor
4121 of <code>A</code> shall not throw exceptions.</p>
4122 </dd>
4123 <dt class="hdlist1">Effects</dt>
4124 <dd>
4125 <p>Allocates memory for an object of type <code>T</code>  or <code>n</code> objects of <code>U</code>
4126 (if <code>T</code> is an array type of the form <code>U[]</code> and  <code>n</code> is determined by
4127 arguments, as specified by the concrete overload). The object is initialized
4128 from arguments as specified by the concrete overload. Uses a rebound copy of
4129 <code>a</code> (for an unspecified <code>value_type</code>) to allocate memory. If an exception is
4130 thrown, the functions have no effect.</p>
4131 </dd>
4132 <dt class="hdlist1">Returns</dt>
4133 <dd>
4134 <p>A <code>shared_ptr</code> instance that stores and owns the address of the
4135 newly constructed object.</p>
4136 </dd>
4137 <dt class="hdlist1">Postconditions</dt>
4138 <dd>
4139 <p><code>r.get() != 0</code> and <code>r.use_count() == 1</code>, where <code>r</code>
4140 is the return value.</p>
4141 </dd>
4142 <dt class="hdlist1">Throws</dt>
4143 <dd>
4144 <p><code>std::bad_alloc</code>, an exception thrown from <code>A::allocate</code>, or from the
4145 initialization of the object.</p>
4146 </dd>
4147 <dt class="hdlist1">Remarks</dt>
4148 <dd>
4149 <div class="ulist">
4150 <ul>
4151 <li>
4152 <p>Performs no more than one memory allocation. This provides efficiency
4153 equivalent to an intrusive smart pointer.</p>
4154 </li>
4155 <li>
4156 <p>When an object of an array type is specified to be initialized to a value of
4157 the same type <code>v</code>, this shall be interpreted to mean that each array element
4158 of the object is initialized to the corresponding element from <code>v</code>.</p>
4159 </li>
4160 <li>
4161 <p>When an object of an array type is specified to be value-initialized, this
4162 shall be interpreted to mean that each array element of the object is
4163 value-initialized.</p>
4164 </li>
4165 <li>
4166 <p>When a (sub)object of non-array type <code>U</code> is specified to be initialized to
4167 a value <code>v</code>, or constructed from <code>args...</code>, <code>make_shared</code> shall perform
4168 this initialization via the expression <code>::new(p) U(expr)</code> (where
4169 <code><em>expr</em></code> is <code>v</code> or <code>std::forward&lt;Args&gt;(args)...)</code> respectively) and <code>p</code>
4170 has type <code>void*</code> and points to storage suitable to hold an object of type
4171 <code>U</code>.</p>
4172 </li>
4173 <li>
4174 <p>When a (sub)object of non-array type <code>U</code> is specified to be initialized to
4175 a value <code>v</code>, or constructed from <code>args...</code>, <code>allocate_shared</code> shall
4176 perform this initialization via the expression
4177 <code>std::allocator_traits&lt;A2&gt;::construct(a2, p, expr)</code> (where
4178 <code><em>expr</em></code> is <code>v</code> or <code>std::forward&lt;Args&gt;(args)...)</code> respectively), <code>p</code>
4179 points to storage suitable to hold an object of type <code>U</code>, and <code>a2</code> of
4180 type <code>A2</code> is a potentially rebound copy of <code>a</code>.</p>
4181 </li>
4182 <li>
4183 <p>When a (sub)object of non-array type <code>U</code> is specified to be
4184 default-initialized, <code>make_shared_noinit</code> and <code>allocate_shared_noinit</code> shall
4185 perform this initialization via the expression <code>::new(p) U</code>, where
4186 <code>p</code> has type <code>void*</code> and points to storage suitable to hold an object of
4187 type <code>U</code>.</p>
4188 </li>
4189 <li>
4190 <p>When a (sub)object of non-array type <code>U</code> is specified to be
4191 value-initialized, <code>make_shared</code> shall perform this initialization via the
4192 expression <code>::new(p) U()</code>, where <code>p</code> has type <code>void*</code> and points to
4193 storage suitable to hold an object of type <code>U</code>.</p>
4194 </li>
4195 <li>
4196 <p>When a (sub)object of non-array type <code>U</code> is specified to be
4197 value-initialized, <code>allocate_shared</code> shall perform this initialization via the
4198 expression <code>std::allocator_traits&lt;A2&gt;::construct(a2, p)</code>, where
4199 <code>p</code> points to storage suitable to hold an object of type <code>U</code> and <code>a2</code> of
4200 type <code>A2</code> is a potentially rebound copy of <code>a</code>.</p>
4201 </li>
4202 <li>
4203 <p>Array elements are initialized in ascending order of their addresses.</p>
4204 </li>
4205 <li>
4206 <p>When the lifetime of the object managed by the return value ends, or when
4207 the initialization of an array element throws an exception, the initialized
4208 elements should be destroyed in the reverse order of their construction.</p>
4209 </li>
4210 </ul>
4211 </div>
4212 </dd>
4213 </dl>
4214 </div>
4215 <div class="admonitionblock note">
4216 <table>
4217 <tr>
4218 <td class="icon">
4219 <div class="title">Note</div>
4220 </td>
4221 <td class="content">
4222 These functions will typically allocate more memory than the total size
4223 of the element objects to allow for internal bookkeeping structures such as
4224 the reference counts.
4225 </td>
4226 </tr>
4227 </table>
4228 </div>
4229 </div>
4230 <div class="sect2">
4231 <h3 id="make_shared_free_functions">Free Functions</h3>
4232 <div class="listingblock">
4233 <div class="content">
4234 <pre class="highlight"><code>template&lt;class T, class... Args&gt;
4235   shared_ptr&lt;T&gt; make_shared(Args&amp;&amp;... args);</code></pre>
4236 </div>
4237 </div>
4238 <div class="listingblock">
4239 <div class="content">
4240 <pre class="highlight"><code>template&lt;class T, class A, class... Args&gt;
4241   shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);</code></pre>
4242 </div>
4243 </div>
4244 <div class="ulist none">
4245 <ul class="none">
4246 <li>
4247 <p></p>
4248 <div class="dlist">
4249 <dl>
4250 <dt class="hdlist1">Constraints</dt>
4251 <dd>
4252 <p><code>T</code> is not an array.</p>
4253 </dd>
4254 <dt class="hdlist1">Returns</dt>
4255 <dd>
4256 <p>A <code>shared_ptr</code> to an object of type <code>T</code>, constructed from
4257 <code>args...</code>.</p>
4258 </dd>
4259 <dt class="hdlist1">Examples</dt>
4260 </dl>
4261 </div>
4262 </li>
4263 <li>
4264 <p><code>auto p = make_shared&lt;int&gt;();</code></p>
4265 </li>
4266 <li>
4267 <p><code>auto p = make_shared&lt;std::vector&lt;int&gt; &gt;(16, 1);</code></p>
4268 </li>
4269 </ul>
4270 </div>
4271 <div class="listingblock">
4272 <div class="content">
4273 <pre class="highlight"><code>template&lt;class T&gt;
4274   shared_ptr&lt;T&gt; make_shared(std::size_t n);</code></pre>
4275 </div>
4276 </div>
4277 <div class="listingblock">
4278 <div class="content">
4279 <pre class="highlight"><code>template&lt;class T, class A&gt;
4280   shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, std::size_t n);</code></pre>
4281 </div>
4282 </div>
4283 <div class="ulist none">
4284 <ul class="none">
4285 <li>
4286 <p></p>
4287 <div class="dlist">
4288 <dl>
4289 <dt class="hdlist1">Constraints</dt>
4290 <dd>
4291 <p><code>T</code> is an array of unknown bounds.</p>
4292 </dd>
4293 <dt class="hdlist1">Returns</dt>
4294 <dd>
4295 <p>A <code>shared_ptr</code> to a sequence of <code>n</code> value-initialized objects of
4296 type <code>remove_extent_t&lt;T&gt;</code>.</p>
4297 </dd>
4298 <dt class="hdlist1">Examples</dt>
4299 </dl>
4300 </div>
4301 </li>
4302 <li>
4303 <p><code>auto p = make_shared&lt;double[]&gt;(1024);</code></p>
4304 </li>
4305 <li>
4306 <p><code>auto p = make_shared&lt;double[][2][2]&gt;(6);</code></p>
4307 </li>
4308 </ul>
4309 </div>
4310 <div class="listingblock">
4311 <div class="content">
4312 <pre class="highlight"><code>template&lt;class T&gt;
4313   shared_ptr&lt;T&gt; make_shared();</code></pre>
4314 </div>
4315 </div>
4316 <div class="listingblock">
4317 <div class="content">
4318 <pre class="highlight"><code>template&lt;class T, class A&gt;
4319   shared_ptr&lt;T&gt; allocate_shared(const A&amp; a);</code></pre>
4320 </div>
4321 </div>
4322 <div class="ulist none">
4323 <ul class="none">
4324 <li>
4325 <p></p>
4326 <div class="dlist">
4327 <dl>
4328 <dt class="hdlist1">Constraints</dt>
4329 <dd>
4330 <p><code>T</code> is an array of known bounds.</p>
4331 </dd>
4332 <dt class="hdlist1">Returns</dt>
4333 <dd>
4334 <p>A <code>shared_ptr</code> to a sequence of <code>extent_v&lt;T&gt;</code> value-initialized
4335 objects of type <code>remove_extent_t&lt;T&gt;</code>.</p>
4336 </dd>
4337 <dt class="hdlist1">Examples</dt>
4338 </dl>
4339 </div>
4340 </li>
4341 <li>
4342 <p><code>auto p = make_shared&lt;double[1024]&gt;();</code></p>
4343 </li>
4344 <li>
4345 <p><code>auto p = make_shared&lt;double[6][2][2]&gt;();</code></p>
4346 </li>
4347 </ul>
4348 </div>
4349 <div class="listingblock">
4350 <div class="content">
4351 <pre class="highlight"><code>template&lt;class T&gt; shared_ptr&lt;T&gt;
4352   make_shared(std::size_t n, const remove_extent_t&lt;T&gt;&amp; v);</code></pre>
4353 </div>
4354 </div>
4355 <div class="listingblock">
4356 <div class="content">
4357 <pre class="highlight"><code>template&lt;class T, class A&gt; shared_ptr&lt;T&gt;
4358   allocate_shared(const A&amp; a, std::size_t n, const remove_extent_t&lt;T&gt;&amp; v);</code></pre>
4359 </div>
4360 </div>
4361 <div class="ulist none">
4362 <ul class="none">
4363 <li>
4364 <p></p>
4365 <div class="dlist">
4366 <dl>
4367 <dt class="hdlist1">Constraints</dt>
4368 <dd>
4369 <p><code>T</code> is an array of unknown bounds.</p>
4370 </dd>
4371 <dt class="hdlist1">Returns</dt>
4372 <dd>
4373 <p>A <code>shared_ptr</code> to a sequence of <code>n</code> objects of type
4374 <code>remove_extent_t&lt;T&gt;</code>, each initialized to <code>v</code>.</p>
4375 </dd>
4376 <dt class="hdlist1">Examples</dt>
4377 </dl>
4378 </div>
4379 </li>
4380 <li>
4381 <p><code>auto p = make_shared&lt;double[]&gt;(1024, 1.0);</code></p>
4382 </li>
4383 <li>
4384 <p><code>auto p = make_shared&lt;double[][2]&gt;(6, {1.0, 0.0});</code></p>
4385 </li>
4386 <li>
4387 <p><code>auto p = make_shared&lt;std::vector&lt;int&gt;[]&gt;(4, {1, 2});</code></p>
4388 </li>
4389 </ul>
4390 </div>
4391 <div class="listingblock">
4392 <div class="content">
4393 <pre class="highlight"><code>template&lt;class T&gt;
4394   shared_ptr&lt;T&gt; make_shared(const remove_extent_t&lt;T&gt;&amp; v);</code></pre>
4395 </div>
4396 </div>
4397 <div class="listingblock">
4398 <div class="content">
4399 <pre class="highlight"><code>template&lt;class T, class A&gt;
4400   shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, const remove_extent_t&lt;T&gt;&amp; v);</code></pre>
4401 </div>
4402 </div>
4403 <div class="ulist none">
4404 <ul class="none">
4405 <li>
4406 <p></p>
4407 <div class="dlist">
4408 <dl>
4409 <dt class="hdlist1">Constraints</dt>
4410 <dd>
4411 <p><code>T</code> is an array of known bounds.</p>
4412 </dd>
4413 <dt class="hdlist1">Returns</dt>
4414 <dd>
4415 <p>A <code>shared_ptr</code> to a sequence of <code>extent_v&lt;T&gt;</code> objects of type
4416 <code>remove_extent_t&lt;T&gt;</code>, each initialized to <code>v</code>.</p>
4417 </dd>
4418 <dt class="hdlist1">Examples</dt>
4419 </dl>
4420 </div>
4421 </li>
4422 <li>
4423 <p><code>auto p = make_shared&lt;double[1024]&gt;(1.0);</code></p>
4424 </li>
4425 <li>
4426 <p><code>auto p = make_shared&lt;double[6][2]&gt;({1.0, 0.0});</code></p>
4427 </li>
4428 <li>
4429 <p><code>auto p = make_shared&lt;std::vector&lt;int&gt;[4]&gt;({1, 2});</code></p>
4430 </li>
4431 </ul>
4432 </div>
4433 <div class="listingblock">
4434 <div class="content">
4435 <pre class="highlight"><code>template&lt;class T&gt;
4436   shared_ptr&lt;T&gt; make_shared_noinit();</code></pre>
4437 </div>
4438 </div>
4439 <div class="listingblock">
4440 <div class="content">
4441 <pre class="highlight"><code>template&lt;class T, class A&gt;
4442   shared_ptr&lt;T&gt; allocate_shared_noinit(const A&amp; a);</code></pre>
4443 </div>
4444 </div>
4445 <div class="ulist none">
4446 <ul class="none">
4447 <li>
4448 <p></p>
4449 <div class="dlist">
4450 <dl>
4451 <dt class="hdlist1">Constraints</dt>
4452 <dd>
4453 <p><code>T</code> is not an array, or is an array of known bounds.</p>
4454 </dd>
4455 <dt class="hdlist1">Returns</dt>
4456 <dd>
4457 <p>A <code>shared_ptr</code> to a default-initialized object of type <code>T</code>, or a
4458 sequence of <code>extent_v&lt;T&gt;</code> default-initialized objects of type
4459 <code>remove_extent_t&lt;T&gt;</code>, respectively.</p>
4460 </dd>
4461 <dt class="hdlist1">Example</dt>
4462 <dd>
4463 <p><code>auto p = make_shared_noinit&lt;double[1024]&gt;();</code></p>
4464 </dd>
4465 </dl>
4466 </div>
4467 </li>
4468 </ul>
4469 </div>
4470 <div class="listingblock">
4471 <div class="content">
4472 <pre class="highlight"><code>template&lt;class T&gt;
4473   shared_ptr&lt;T&gt; make_shared_noinit(std::size_t n);</code></pre>
4474 </div>
4475 </div>
4476 <div class="listingblock">
4477 <div class="content">
4478 <pre class="highlight"><code>template&lt;class T, class A&gt;
4479   shared_ptr&lt;T&gt; allocate_shared_noinit(const A&amp; a, std::size_t n);</code></pre>
4480 </div>
4481 </div>
4482 <div class="ulist none">
4483 <ul class="none">
4484 <li>
4485 <p></p>
4486 <div class="dlist">
4487 <dl>
4488 <dt class="hdlist1">Constraints</dt>
4489 <dd>
4490 <p><code>T</code> is an array of unknown bounds.</p>
4491 </dd>
4492 <dt class="hdlist1">Returns</dt>
4493 <dd>
4494 <p>A <code>shared_ptr</code> to a sequence of <code><em>n</em></code> default-initialized objects
4495 of type <code>remove_extent_t&lt;T&gt;</code>.</p>
4496 </dd>
4497 <dt class="hdlist1">Example</dt>
4498 <dd>
4499 <p><code>auto p = make_shared_noinit&lt;double[]&gt;(1024);</code></p>
4500 </dd>
4501 </dl>
4502 </div>
4503 </li>
4504 </ul>
4505 </div>
4506 </div>
4507 </div>
4508 </div>
4509 <div class="sect1">
4510 <h2 id="enable_shared_from_this">enable_shared_from_this</h2>
4511 <div class="sectionbody">
4512 <div class="sect2">
4513 <h3 id="enable_shared_from_this_description">Description</h3>
4514 <div class="paragraph">
4515 <p>The class template <code>enable_shared_from_this</code> is used as a base class that allows
4516 a <code>shared_ptr</code> or a <code>weak_ptr</code> to the current object to be obtained from within a
4517 member function.</p>
4518 </div>
4519 <div class="paragraph">
4520 <p><code>enable_shared_from_this&lt;T&gt;</code> defines two member functions called <code>shared_from_this</code>
4521 that return a <code>shared_ptr&lt;T&gt;</code> and <code>shared_ptr&lt;T const&gt;</code>, depending on constness, to
4522 <code>this</code>. It also defines two member functions called <code>weak_from_this</code> that return a
4523 corresponding <code>weak_ptr</code>.</p>
4524 </div>
4525 </div>
4526 <div class="sect2">
4527 <h3 id="enable_shared_from_this_example">Example</h3>
4528 <div class="listingblock">
4529 <div class="content">
4530 <pre class="highlight"><code>#include &lt;boost/enable_shared_from_this.hpp&gt;
4531 #include &lt;boost/shared_ptr.hpp&gt;
4532 #include &lt;cassert&gt;
4533
4534 class Y: public boost::enable_shared_from_this&lt;Y&gt;
4535 {
4536 public:
4537
4538     boost::shared_ptr&lt;Y&gt; f()
4539     {
4540         return shared_from_this();
4541     }
4542 };
4543
4544 int main()
4545 {
4546     boost::shared_ptr&lt;Y&gt; p(new Y);
4547     boost::shared_ptr&lt;Y&gt; q = p-&gt;f();
4548     assert(p == q);
4549     assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
4550 }</code></pre>
4551 </div>
4552 </div>
4553 </div>
4554 <div class="sect2">
4555 <h3 id="enable_shared_from_this_synopsis">Synopsis</h3>
4556 <div class="paragraph">
4557 <p><code>enable_shared_from_this</code> is defined in <code>&lt;boost/smart_ptr/enable_shared_from_this.hpp&gt;</code>.</p>
4558 </div>
4559 <div class="listingblock">
4560 <div class="content">
4561 <pre class="highlight"><code>namespace boost {
4562
4563   template&lt;class T&gt; class enable_shared_from_this {
4564   private:
4565
4566     // exposition only
4567     weak_ptr&lt;T&gt; weak_this_;
4568
4569   protected:
4570
4571     enable_shared_from_this() = default;
4572     ~enable_shared_from_this() = default;
4573
4574     enable_shared_from_this(const enable_shared_from_this&amp;) noexcept;
4575     enable_shared_from_this&amp; operator=(const enable_shared_from_this&amp;) noexcept;
4576
4577   public:
4578
4579     shared_ptr&lt;T&gt; shared_from_this();
4580     shared_ptr&lt;T const&gt; shared_from_this() const;
4581
4582     weak_ptr&lt;T&gt; weak_from_this() noexcept;
4583     weak_ptr&lt;T const&gt; weak_from_this() const noexcept;
4584   }
4585 }</code></pre>
4586 </div>
4587 </div>
4588 </div>
4589 <div class="sect2">
4590 <h3 id="enable_shared_from_this_members">Members</h3>
4591 <div class="listingblock">
4592 <div class="content">
4593 <pre class="highlight"><code>enable_shared_from_this(enable_shared_from_this const &amp;) noexcept;</code></pre>
4594 </div>
4595 </div>
4596 <div class="ulist none">
4597 <ul class="none">
4598 <li>
4599 <p></p>
4600 <div class="dlist">
4601 <dl>
4602 <dt class="hdlist1">Effects</dt>
4603 <dd>
4604 <p>Default-constructs <code>weak_this_</code>.</p>
4605 </dd>
4606 </dl>
4607 </div>
4608 </li>
4609 </ul>
4610 </div>
4611 <div class="admonitionblock note">
4612 <table>
4613 <tr>
4614 <td class="icon">
4615 <div class="title">Note</div>
4616 </td>
4617 <td class="content">
4618 <code>weak_this_</code> is <em>not</em> copied from the argument.
4619 </td>
4620 </tr>
4621 </table>
4622 </div>
4623 <div class="listingblock">
4624 <div class="content">
4625 <pre class="highlight"><code>enable_shared_from_this&amp; operator=(enable_shared_from_this const &amp;) noexcept;</code></pre>
4626 </div>
4627 </div>
4628 <div class="ulist none">
4629 <ul class="none">
4630 <li>
4631 <p></p>
4632 <div class="dlist">
4633 <dl>
4634 <dt class="hdlist1">Returns</dt>
4635 <dd>
4636 <p><code>*this</code>.</p>
4637 </dd>
4638 </dl>
4639 </div>
4640 </li>
4641 </ul>
4642 </div>
4643 <div class="admonitionblock note">
4644 <table>
4645 <tr>
4646 <td class="icon">
4647 <div class="title">Note</div>
4648 </td>
4649 <td class="content">
4650 <code>weak_this_</code> is unchanged.
4651 </td>
4652 </tr>
4653 </table>
4654 </div>
4655 <div class="listingblock">
4656 <div class="content">
4657 <pre class="highlight"><code>template&lt;class T&gt; shared_ptr&lt;T&gt; shared_from_this();</code></pre>
4658 </div>
4659 </div>
4660 <div class="listingblock">
4661 <div class="content">
4662 <pre class="highlight"><code>template&lt;class T&gt; shared_ptr&lt;T const&gt; shared_from_this() const;</code></pre>
4663 </div>
4664 </div>
4665 <div class="ulist none">
4666 <ul class="none">
4667 <li>
4668 <p></p>
4669 <div class="dlist">
4670 <dl>
4671 <dt class="hdlist1">Returns</dt>
4672 <dd>
4673 <p><code>shared_ptr&lt;T&gt;(weak_this_)</code>.</p>
4674 </dd>
4675 </dl>
4676 </div>
4677 </li>
4678 </ul>
4679 </div>
4680 <div class="admonitionblock note">
4681 <table>
4682 <tr>
4683 <td class="icon">
4684 <div class="title">Note</div>
4685 </td>
4686 <td class="content">
4687 These members throw <code>bad_weak_ptr</code> when <code>*this</code> is not owned by a <code>shared_ptr</code>.
4688 </td>
4689 </tr>
4690 </table>
4691 </div>
4692 <div class="admonitionblock note">
4693 <table>
4694 <tr>
4695 <td class="icon">
4696 <div class="title">Note</div>
4697 </td>
4698 <td class="content">
4699 <div class="paragraph">
4700 <p><code>weak_this_</code> is initialized by <code>shared_ptr</code> to a copy of itself when it&#8217;s constructed by a pointer to <code>*this</code>.
4701 For example, in the following code:</p>
4702 </div>
4703 <div class="listingblock">
4704 <div class="content">
4705 <pre class="highlight"><code>class Y: public boost::enable_shared_from_this&lt;Y&gt; {};
4706
4707 int main()
4708 {
4709     boost::shared_ptr&lt;Y&gt; p(new Y);
4710 }</code></pre>
4711 </div>
4712 </div>
4713 <div class="paragraph">
4714 <p>the construction of <code>p</code> will automatically initialize <code>p-&gt;weak_this_</code> to <code>p</code>.</p>
4715 </div>
4716 </td>
4717 </tr>
4718 </table>
4719 </div>
4720 <div class="listingblock">
4721 <div class="content">
4722 <pre class="highlight"><code>template&lt;class T&gt; weak_ptr&lt;T&gt; weak_from_this() noexcept;</code></pre>
4723 </div>
4724 </div>
4725 <div class="listingblock">
4726 <div class="content">
4727 <pre class="highlight"><code>template&lt;class T&gt; weak_ptr&lt;T const&gt; weak_from_this() const noexcept;</code></pre>
4728 </div>
4729 </div>
4730 <div class="ulist none">
4731 <ul class="none">
4732 <li>
4733 <p></p>
4734 <div class="dlist">
4735 <dl>
4736 <dt class="hdlist1">Returns</dt>
4737 <dd>
4738 <p><code>weak_this_</code>.</p>
4739 </dd>
4740 </dl>
4741 </div>
4742 </li>
4743 </ul>
4744 </div>
4745 <div class="admonitionblock note">
4746 <table>
4747 <tr>
4748 <td class="icon">
4749 <div class="title">Note</div>
4750 </td>
4751 <td class="content">
4752 Unlike <code>shared_from_this()</code>, <code>weak_from_this()</code> is valid in a destructor
4753       and returns a <code>weak_ptr</code> that is <code>expired()</code> but still shares ownership
4754       with other <code>weak_ptr</code> instances (if any) that refer to the object.
4755 </td>
4756 </tr>
4757 </table>
4758 </div>
4759 </div>
4760 </div>
4761 </div>
4762 <div class="sect1">
4763 <h2 id="enable_shared_from">enable_shared_from</h2>
4764 <div class="sectionbody">
4765 <div class="sect2">
4766 <h3 id="enable_shared_from_description">Description</h3>
4767 <div class="paragraph">
4768 <p><code>enable_shared_from</code> is used as a base class that allows a <code>shared_ptr</code> or a
4769 <code>weak_ptr</code> to be obtained given a raw pointer to the object, by using the
4770 functions <code>shared_from</code> and <code>weak_from</code>.</p>
4771 </div>
4772 <div class="paragraph">
4773 <p><code>enable_shared_from</code> differs from <code>enable_shared_from_this&lt;T&gt;</code> by the fact
4774 that it&#8217;s not a template, and is its recommended replacement for new code.</p>
4775 </div>
4776 </div>
4777 <div class="sect2">
4778 <h3 id="enable_shared_from_example">Example</h3>
4779 <div class="listingblock">
4780 <div class="content">
4781 <pre class="highlight"><code>#include &lt;boost/smart_ptr/enable_shared_from.hpp&gt;
4782 #include &lt;boost/shared_ptr.hpp&gt;
4783 #include &lt;cassert&gt;
4784
4785 class Y: public boost::enable_shared_from
4786 {
4787 public:
4788
4789     boost::shared_ptr&lt;Y&gt; f()
4790     {
4791         return boost::shared_from( this );
4792     }
4793 };
4794
4795 int main()
4796 {
4797     boost::shared_ptr&lt;Y&gt; p(new Y);
4798     boost::shared_ptr&lt;Y&gt; q = p-&gt;f();
4799     assert(p == q);
4800     assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
4801 }</code></pre>
4802 </div>
4803 </div>
4804 </div>
4805 <div class="sect2">
4806 <h3 id="enable_shared_from_synopsis">Synopsis</h3>
4807 <div class="paragraph">
4808 <p><code>enable_shared_from</code> is defined in <code>&lt;boost/smart_ptr/enable_shared_from.hpp&gt;</code>.</p>
4809 </div>
4810 <div class="listingblock">
4811 <div class="content">
4812 <pre class="highlight"><code>namespace boost {
4813
4814   class enable_shared_from: public enable_shared_from_this&lt;enable_shared_from&gt;
4815   {
4816   };
4817
4818   template&lt;class T&gt; shared_ptr&lt;T&gt; shared_from( T * p );
4819   template&lt;class T&gt; weak_ptr&lt;T&gt; weak_from( T * p ) noexcept;
4820 }</code></pre>
4821 </div>
4822 </div>
4823 </div>
4824 <div class="sect2">
4825 <h3 id="enable_shared_from_functions">Functions</h3>
4826 <div class="listingblock">
4827 <div class="content">
4828 <pre class="highlight"><code>template&lt;class T&gt; shared_ptr&lt;T&gt; shared_from( T * p );</code></pre>
4829 </div>
4830 </div>
4831 <div class="ulist none">
4832 <ul class="none">
4833 <li>
4834 <p></p>
4835 <div class="dlist">
4836 <dl>
4837 <dt class="hdlist1">Returns</dt>
4838 <dd>
4839 <p><code>shared_ptr&lt;T&gt;( p-&gt;enable_shared_from::shared_from_this(), p )</code>.</p>
4840 </dd>
4841 </dl>
4842 </div>
4843 </li>
4844 </ul>
4845 </div>
4846 <div class="admonitionblock note">
4847 <table>
4848 <tr>
4849 <td class="icon">
4850 <div class="title">Note</div>
4851 </td>
4852 <td class="content">
4853 Throws <code>bad_weak_ptr</code> when <code>p</code> is not owned by a <code>shared_ptr</code>.
4854 </td>
4855 </tr>
4856 </table>
4857 </div>
4858 <div class="listingblock">
4859 <div class="content">
4860 <pre class="highlight"><code>template&lt;class T&gt; weak_ptr&lt;T&gt; weak_from( T * p ) noexcept;</code></pre>
4861 </div>
4862 </div>
4863 <div class="ulist none">
4864 <ul class="none">
4865 <li>
4866 <p></p>
4867 <div class="dlist">
4868 <dl>
4869 <dt class="hdlist1">Returns</dt>
4870 <dd>
4871 <p><code>weak_ptr&lt;T&gt;( p-&gt;enable_shared_from::weak_from_this(), p )</code>.</p>
4872 </dd>
4873 </dl>
4874 </div>
4875 </li>
4876 </ul>
4877 </div>
4878 <div class="admonitionblock note">
4879 <table>
4880 <tr>
4881 <td class="icon">
4882 <div class="title">Note</div>
4883 </td>
4884 <td class="content">
4885 Unlike <code>shared_from(this)</code>, <code>weak_from(this)</code> is valid in a destructor
4886       and returns a <code>weak_ptr</code> that is <code>expired()</code> but still shares ownership
4887       with other <code>weak_ptr</code> instances (if any) that refer to the object.
4888 </td>
4889 </tr>
4890 </table>
4891 </div>
4892 </div>
4893 </div>
4894 </div>
4895 <div class="sect1">
4896 <h2 id="make_unique">make_unique: Creating unique_ptr</h2>
4897 <div class="sectionbody">
4898 <div class="sect2">
4899 <h3 id="make_unique_description">Description</h3>
4900 <div class="paragraph">
4901 <p>The <code>make_unique</code> function templates provide convenient and safe ways to
4902 create <code>std::unique_ptr</code> objects.</p>
4903 </div>
4904 </div>
4905 <div class="sect2">
4906 <h3 id="make_unique_rationale">Rationale</h3>
4907 <div class="paragraph">
4908 <p>The C&#43;&#43;11 standard introduced <code>std::unique_ptr</code> but did not provide any
4909 <code>make_unique</code> utility like <code>std::make_shared</code> that provided the same
4910 exception safety and facility to avoid writing <code>new</code> expressions. Before it
4911 was implemented by some standard library vendors (and prior to the C&#43;&#43;14
4912 standard introducing <code>std::make_unique</code>), this library provided it due to
4913 requests from users.</p>
4914 </div>
4915 <div class="paragraph">
4916 <p>This library also provides additional overloads of <code>make_unique</code> for
4917 default-initialization, when users do not need or want to incur the expense
4918 of value-initialization. The C&#43;&#43; standard does not yet provide this
4919 feature with <code>std::make_unique</code>.</p>
4920 </div>
4921 </div>
4922 <div class="sect2">
4923 <h3 id="make_unique_synopsis">Synopsis</h3>
4924 <div class="paragraph">
4925 <p><code>make_unique</code> is defined in <code>&lt;boost/smart_ptr/make_unique.hpp&gt;</code>.</p>
4926 </div>
4927 <div class="listingblock">
4928 <div class="content">
4929 <pre class="highlight"><code>namespace boost {
4930   <code>// T is not an array</code>
4931   template&lt;class T, class... Args&gt;
4932     std::unique_ptr&lt;T&gt; make_unique(Args&amp;&amp;... args);
4933
4934   <code>// T is not an array</code>
4935   template&lt;class T&gt;
4936     std::unique_ptr&lt;T&gt; make_unique(type_identity_t&lt;T&gt;&amp;&amp; v);
4937
4938   <code>// T is an array of unknown bounds</code>
4939   template&lt;class T&gt;
4940     std::unique_ptr&lt;T&gt; make_unique(std::size_t n);
4941
4942   <code>// T is not an array</code>
4943   template&lt;class T&gt;
4944     std::unique_ptr&lt;T&gt; make_unique_noinit();
4945
4946   <code>// T is an array of unknown bounds</code>
4947   template&lt;class T&gt;
4948     std::unique_ptr&lt;T&gt; make_unique_noinit(std::size_t n);
4949 }</code></pre>
4950 </div>
4951 </div>
4952 </div>
4953 <div class="sect2">
4954 <h3 id="make_unique_free_functions">Free Functions</h3>
4955 <div class="listingblock">
4956 <div class="content">
4957 <pre class="highlight"><code>template&lt;class T, class... Args&gt;
4958   std::unique_ptr&lt;T&gt; make_unique(Args&amp;&amp;... args);</code></pre>
4959 </div>
4960 </div>
4961 <div class="ulist none">
4962 <ul class="none">
4963 <li>
4964 <p></p>
4965 <div class="dlist">
4966 <dl>
4967 <dt class="hdlist1">Constraints</dt>
4968 <dd>
4969 <p><code>T</code> is not an array.</p>
4970 </dd>
4971 <dt class="hdlist1">Returns</dt>
4972 <dd>
4973 <p><code>std::unique_ptr&lt;T&gt;(new T(std::forward&lt;Args&gt;(args)...)</code>.</p>
4974 </dd>
4975 <dt class="hdlist1">Example</dt>
4976 <dd>
4977 <p><code>auto p = make_unique&lt;int&gt;();</code></p>
4978 </dd>
4979 </dl>
4980 </div>
4981 </li>
4982 </ul>
4983 </div>
4984 <div class="listingblock">
4985 <div class="content">
4986 <pre class="highlight"><code>template&lt;class T&gt;
4987   std::unique_ptr&lt;T&gt; make_unique(type_identity_t&lt;T&gt;&amp;&amp; v);</code></pre>
4988 </div>
4989 </div>
4990 <div class="ulist none">
4991 <ul class="none">
4992 <li>
4993 <p></p>
4994 <div class="dlist">
4995 <dl>
4996 <dt class="hdlist1">Constraints</dt>
4997 <dd>
4998 <p><code>T</code> is not an array.</p>
4999 </dd>
5000 <dt class="hdlist1">Returns</dt>
5001 <dd>
5002 <p><code>std::unique_ptr&lt;T&gt;(new T(std::move(v))</code>.</p>
5003 </dd>
5004 <dt class="hdlist1">Example</dt>
5005 <dd>
5006 <p><code>auto p = make_unique&lt;std::vector&lt;int&gt; &gt;({1, 2});</code></p>
5007 </dd>
5008 </dl>
5009 </div>
5010 </li>
5011 </ul>
5012 </div>
5013 <div class="listingblock">
5014 <div class="content">
5015 <pre class="highlight"><code>template&lt;class T&gt;
5016   std::unique_ptr&lt;T&gt; make_unique(std::size_t n);</code></pre>
5017 </div>
5018 </div>
5019 <div class="ulist none">
5020 <ul class="none">
5021 <li>
5022 <p></p>
5023 <div class="dlist">
5024 <dl>
5025 <dt class="hdlist1">Constraints</dt>
5026 <dd>
5027 <p><code>T</code> is an array of unknown bounds.</p>
5028 </dd>
5029 <dt class="hdlist1">Returns</dt>
5030 <dd>
5031 <p><code>std::unique_ptr&lt;T&gt;(new remove_extent_t&lt;T&gt;[n]())</code>.</p>
5032 </dd>
5033 <dt class="hdlist1">Example</dt>
5034 <dd>
5035 <p><code>auto p = make_unique&lt;double[]&gt;(1024);</code></p>
5036 </dd>
5037 </dl>
5038 </div>
5039 </li>
5040 </ul>
5041 </div>
5042 <div class="listingblock">
5043 <div class="content">
5044 <pre class="highlight"><code>template&lt;class T&gt;
5045   std::unique_ptr&lt;T&gt; make_unique_noinit();</code></pre>
5046 </div>
5047 </div>
5048 <div class="ulist none">
5049 <ul class="none">
5050 <li>
5051 <p></p>
5052 <div class="dlist">
5053 <dl>
5054 <dt class="hdlist1">Constraints</dt>
5055 <dd>
5056 <p><code>T</code> is not an array.</p>
5057 </dd>
5058 <dt class="hdlist1">Returns</dt>
5059 <dd>
5060 <p><code>std::unique_ptr&lt;T&gt;(new T)</code>.</p>
5061 </dd>
5062 <dt class="hdlist1">Example</dt>
5063 <dd>
5064 <p><code>auto p = make_unique_noinit&lt;double[1024]&gt;();</code></p>
5065 </dd>
5066 </dl>
5067 </div>
5068 </li>
5069 </ul>
5070 </div>
5071 <div class="listingblock">
5072 <div class="content">
5073 <pre class="highlight"><code>template&lt;class T&gt;
5074   std::unique_ptr&lt;T&gt; make_unique_noinit(std::size_t n);</code></pre>
5075 </div>
5076 </div>
5077 <div class="ulist none">
5078 <ul class="none">
5079 <li>
5080 <p></p>
5081 <div class="dlist">
5082 <dl>
5083 <dt class="hdlist1">Constraints</dt>
5084 <dd>
5085 <p><code>T</code> is an array of unknown bounds.</p>
5086 </dd>
5087 <dt class="hdlist1">Returns</dt>
5088 <dd>
5089 <p><code>std::unique_ptr&lt;T&gt;(new remove_extent_t&lt;T&gt;[n])</code>.</p>
5090 </dd>
5091 <dt class="hdlist1">Example</dt>
5092 <dd>
5093 <p><code>auto p = make_unique_noinit&lt;double[]&gt;(1024);</code></p>
5094 </dd>
5095 </dl>
5096 </div>
5097 </li>
5098 </ul>
5099 </div>
5100 </div>
5101 </div>
5102 </div>
5103 <div class="sect1">
5104 <h2 id="allocate_unique">allocate_unique: Creating unique_ptr</h2>
5105 <div class="sectionbody">
5106 <div class="sect2">
5107 <h3 id="allocate_unique_description">Description</h3>
5108 <div class="paragraph">
5109 <p>The <code>allocate_unique</code> family of function templates provide convenient and safe
5110 ways to obtain a <code>std::unique_ptr</code> that manages a new object created using an
5111 allocator.</p>
5112 </div>
5113 </div>
5114 <div class="sect2">
5115 <h3 id="allocate_unique_rationale">Rationale</h3>
5116 <div class="paragraph">
5117 <p>The C&#43;&#43;14 standard introduced <code>std::make_unique</code> which used operator <code>new</code> to
5118 create new objects. However, there is no convenient facility in the standard
5119 library to use an allocator for the creation of the objects managed by
5120 <code>std::unique_ptr</code>. Users writing allocator aware code have often requested an
5121 <code>allocate_unique</code> factory function. This function is to <code>std::unique_ptr</code> what
5122 <code>std::allocate_shared</code> is to <code>std::shared_ptr</code>.</p>
5123 </div>
5124 </div>
5125 <div class="sect2">
5126 <h3 id="allocate_unique_synopsis">Synopsis</h3>
5127 <div class="paragraph">
5128 <p><code>allocate_unique</code> is defined in <code>&lt;boost/smart_ptr/allocate_unique.hpp&gt;</code>.</p>
5129 </div>
5130 <div class="listingblock">
5131 <div class="content">
5132 <pre class="highlight"><code>namespace boost {
5133   template&lt;class T, class A&gt;
5134   class alloc_deleter;
5135
5136   template&lt;class T, class A&gt;
5137   using alloc_noinit_deleter = alloc_deleter&lt;T, noinit_adaptor&lt;A&gt;&gt;;
5138
5139   <code>// T is not an array</code>
5140   template&lt;class T, class A, class... Args&gt;
5141     std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5142       allocate_unique(const A&amp; a, Args&amp;&amp;... args);
5143
5144   <code>// T is not an array</code>
5145   template&lt;class T, class A&gt;
5146     std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5147       allocate_unique(const A&amp; a, type_identity_t&lt;T&gt;&amp;&amp; v);
5148
5149   <code>// T is an array of unknown bounds</code>
5150   template&lt;class T, class A&gt;
5151     std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5152       allocate_unique(const A&amp; a, std::size_t n);
5153
5154   <code>// T is an array of known bounds</code>
5155   template&lt;class T, class A&gt;
5156     std::unique_ptr&lt;remove_extent_t&lt;T&gt;[], alloc_deleter&lt;T, A&gt;&gt;
5157       allocate_unique(const A&amp; a);
5158
5159   <code>// T is an array of unknown bounds</code>
5160   template&lt;class T, class A&gt;
5161     std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5162       allocate_unique(const A&amp; a, std::size_t n, const remove_extent_t&lt;T&gt;&amp; v);
5163
5164   <code>// T is an array of known bounds</code>
5165   template&lt;class T, class A&gt;
5166     std::unique_ptr&lt;remove_extent_t&lt;T&gt;[], alloc_deleter&lt;T, A&gt;&gt;
5167       allocate_unique(const A&amp; a, const remove_extent_t&lt;T&gt;&amp; v);
5168
5169   <code>// T is not an array</code>
5170   template&lt;class T, class A&gt;
5171     std::unique_ptr&lt;T, alloc_noinit_deleter&lt;T, A&gt;&gt;
5172       allocate_unique_noinit(const A&amp; a);
5173
5174   <code>// T is an array of unknown bounds</code>
5175   template&lt;class T, class A&gt;
5176     std::unique_ptr&lt;T, alloc_noinit_deleter&lt;T, A&gt;&gt;
5177       allocate_unique_noinit(const A&amp; a, std::size_t n);
5178
5179   <code>// T is an array of known bounds</code>
5180   template&lt;class T, class A&gt;
5181     std::unique_ptr&lt;remove_extent_t&lt;T&gt;[], alloc_noinit_deleter&lt;T, A&gt;&gt;
5182       allocate_unique_noinit(const A&amp; a);
5183 }</code></pre>
5184 </div>
5185 </div>
5186 </div>
5187 <div class="sect2">
5188 <h3 id="allocate_unique_common_requirements">Common Requirements</h3>
5189 <div class="paragraph">
5190 <p>The common requirements that apply to all <code>allocate_unique</code> and
5191 <code>allocate_unique_noinit</code> overloads, unless specified otherwise, are described
5192 below.</p>
5193 </div>
5194 <div class="dlist">
5195 <dl>
5196 <dt class="hdlist1">Requires</dt>
5197 <dd>
5198 <p><code>A</code> shall be an <em>allocator</em>. The copy constructor and destructor
5199 of <code>A</code> shall not throw exceptions.</p>
5200 </dd>
5201 <dt class="hdlist1">Effects</dt>
5202 <dd>
5203 <p>Allocates memory for an object of type <code>T</code> or <code>n</code> objects of <code>U</code>
5204 (if <code>T</code> is an array type of the form <code>U[]</code> and  <code>n</code> is determined by
5205 arguments, as specified by the concrete overload). The object is initialized
5206 from arguments as specified by the concrete overload. Uses a rebound copy of
5207 <code>a</code> (for an unspecified <code>value_type</code>) to allocate memory. If an exception is
5208 thrown, the functions have no effect.</p>
5209 </dd>
5210 <dt class="hdlist1">Returns</dt>
5211 <dd>
5212 <p>A <code>std::unique_ptr</code> instance that stores and owns the address of the
5213 newly constructed object.</p>
5214 </dd>
5215 <dt class="hdlist1">Postconditions</dt>
5216 <dd>
5217 <p><code>r.get() != 0</code>, where <code>r</code> is the return value.</p>
5218 </dd>
5219 <dt class="hdlist1">Throws</dt>
5220 <dd>
5221 <p>An exception thrown from <code>A::allocate</code>, or from the initialization of
5222 the object.</p>
5223 </dd>
5224 <dt class="hdlist1">Remarks</dt>
5225 <dd>
5226 <div class="ulist">
5227 <ul>
5228 <li>
5229 <p>When an object of an array type is specified to be initialized to a value of
5230 the same type <code>v</code>, this shall be interpreted to mean that each array element
5231 of the object is initialized to the corresponding element from <code>v</code>.</p>
5232 </li>
5233 <li>
5234 <p>When an object of an array type is specified to be value-initialized, this
5235 shall be interpreted to mean that each array element of the object is
5236 value-initialized.</p>
5237 </li>
5238 <li>
5239 <p>When a (sub)object of non-array type <code>U</code> is specified to be initialized to a
5240 value <code>v</code>, or constructed from <code>args...</code>, <code>allocate_unique</code> shall perform this
5241 initialization via the expression
5242 <code>std::allocator_traits&lt;A2&gt;::construct(a2, p, expr)</code> (where <code><em>expr</em></code> is <code>v</code> or
5243 <code>std::forward&lt;Args&gt;(args)...)</code> respectively), <code>p</code> points to storage suitable
5244 to hold an object of type <code>U</code>, and <code>a2</code> of type <code>A2</code> is a potentially rebound
5245 copy of <code>a</code>.</p>
5246 </li>
5247 <li>
5248 <p>When a (sub)object of non-array type <code>U</code> is specified to be
5249 default-initialized, <code>allocate_unique_noinit</code> shall perform this initialization
5250 via the expression <code>::new(p) U</code>, where <code>p</code> has type <code>void*</code> and points to
5251 storage suitable to hold an object of type <code>U</code>.</p>
5252 </li>
5253 <li>
5254 <p>When a (sub)object of non-array type <code>U</code> is specified to be
5255 value-initialized, <code>allocate_unique</code> shall perform this initialization via the
5256 expression <code>std::allocator_traits&lt;A2&gt;::construct(a2, p)</code>, where <code>p</code> points to
5257 storage suitable to hold an object of type <code>U</code> and <code>a2</code> of type <code>A2</code> is a
5258 potentially rebound copy of <code>a</code>.</p>
5259 </li>
5260 <li>
5261 <p>Array elements are initialized in ascending order of their addresses.</p>
5262 </li>
5263 <li>
5264 <p>When the lifetime of the object managed by the return value ends, or when the
5265 initialization of an array element throws an exception, the initialized
5266 elements should be destroyed in the reverse order of their construction.</p>
5267 </li>
5268 </ul>
5269 </div>
5270 </dd>
5271 </dl>
5272 </div>
5273 </div>
5274 <div class="sect2">
5275 <h3 id="allocate_unique_free_functions">Free Functions</h3>
5276 <div class="listingblock">
5277 <div class="content">
5278 <pre class="highlight"><code>template&lt;class T, class A, class... Args&gt;
5279   std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5280     allocate_unique(const A&amp; a, Args&amp;&amp;... args);</code></pre>
5281 </div>
5282 </div>
5283 <div class="ulist none">
5284 <ul class="none">
5285 <li>
5286 <p></p>
5287 <div class="dlist">
5288 <dl>
5289 <dt class="hdlist1">Constraints</dt>
5290 <dd>
5291 <p><code>T</code> is not an array.</p>
5292 </dd>
5293 <dt class="hdlist1">Returns</dt>
5294 <dd>
5295 <p>A <code>std::unique_ptr</code> to an object of type <code>T</code>, constructed from
5296 <code>args...</code>.</p>
5297 </dd>
5298 <dt class="hdlist1">Examples</dt>
5299 </dl>
5300 </div>
5301 </li>
5302 <li>
5303 <p><code>auto p = allocate_unique&lt;int&gt;(a);</code></p>
5304 </li>
5305 <li>
5306 <p><code>auto p = allocate_unique&lt;std::vector&lt;int&gt;&gt;(a, 16, 1);</code></p>
5307 </li>
5308 </ul>
5309 </div>
5310 <div class="listingblock">
5311 <div class="content">
5312 <pre class="highlight"><code>template&lt;class T, class A&gt;
5313   std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5314     allocate_unique(const A&amp; a, type_identity_t&lt;T&gt;&amp;&amp; v);</code></pre>
5315 </div>
5316 </div>
5317 <div class="ulist none">
5318 <ul class="none">
5319 <li>
5320 <p></p>
5321 <div class="dlist">
5322 <dl>
5323 <dt class="hdlist1">Constraints</dt>
5324 <dd>
5325 <p><code>T</code> is not an array.</p>
5326 </dd>
5327 <dt class="hdlist1">Returns</dt>
5328 <dd>
5329 <p>A <code>std::unique_ptr</code> to an object of type <code>T</code>, constructed from <code>v</code>.</p>
5330 </dd>
5331 <dt class="hdlist1">Example</dt>
5332 <dd>
5333 <p><code>auto p = allocate_unique&lt;std::vector&lt;int&gt;&gt;(a, {1, 2});</code></p>
5334 </dd>
5335 </dl>
5336 </div>
5337 </li>
5338 </ul>
5339 </div>
5340 <div class="listingblock">
5341 <div class="content">
5342 <pre class="highlight"><code>template&lt;class T, class A&gt;
5343   std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5344     allocate_unique(const A&amp; a, std::size_t n);</code></pre>
5345 </div>
5346 </div>
5347 <div class="ulist none">
5348 <ul class="none">
5349 <li>
5350 <p></p>
5351 <div class="dlist">
5352 <dl>
5353 <dt class="hdlist1">Constraints</dt>
5354 <dd>
5355 <p><code>T</code> is an array of unknown bounds.</p>
5356 </dd>
5357 <dt class="hdlist1">Returns</dt>
5358 <dd>
5359 <p>A <code>std::unique_ptr</code> to a sequence of <code>n</code> value-initialized objects of
5360 type <code>remove_extent_t&lt;T&gt;</code>.</p>
5361 </dd>
5362 <dt class="hdlist1">Examples</dt>
5363 </dl>
5364 </div>
5365 </li>
5366 <li>
5367 <p><code>auto p = allocate_unique&lt;double[]&gt;(a, 1024);</code></p>
5368 </li>
5369 <li>
5370 <p><code>auto p = allocate_unique&lt;double[][2][2]&gt;(a, 6);</code></p>
5371 </li>
5372 </ul>
5373 </div>
5374 <div class="listingblock">
5375 <div class="content">
5376 <pre class="highlight"><code>template&lt;class T, class A&gt;
5377   std::unique_ptr&lt;remove_extent_t&lt;T&gt;[], alloc_deleter&lt;T, A&gt;&gt;
5378     allocate_unique(const A&amp; a);</code></pre>
5379 </div>
5380 </div>
5381 <div class="ulist none">
5382 <ul class="none">
5383 <li>
5384 <p></p>
5385 <div class="dlist">
5386 <dl>
5387 <dt class="hdlist1">Constraints</dt>
5388 <dd>
5389 <p><code>T</code> is an array of known bounds.</p>
5390 </dd>
5391 <dt class="hdlist1">Returns</dt>
5392 <dd>
5393 <p>A <code>std::unique_ptr</code> to a sequence of <code>extent_v&lt;T&gt;</code> value-initialized
5394 objects of type <code>remove_extent_t&lt;T&gt;</code>.</p>
5395 </dd>
5396 <dt class="hdlist1">Examples</dt>
5397 </dl>
5398 </div>
5399 </li>
5400 <li>
5401 <p><code>auto p = allocate_unique&lt;double[1024]&gt;(a);</code></p>
5402 </li>
5403 <li>
5404 <p><code>auto p = allocate_unique&lt;double[6][2][2]&gt;(a);</code></p>
5405 </li>
5406 </ul>
5407 </div>
5408 <div class="listingblock">
5409 <div class="content">
5410 <pre class="highlight"><code>template&lt;class T, class A&gt;
5411   std::unique_ptr&lt;T, alloc_deleter&lt;T, A&gt;&gt;
5412     allocate_unique(const A&amp; a, std::size_t n, const remove_extent_t&lt;T&gt;&amp; v);</code></pre>
5413 </div>
5414 </div>
5415 <div class="ulist none">
5416 <ul class="none">
5417 <li>
5418 <p></p>
5419 <div class="dlist">
5420 <dl>
5421 <dt class="hdlist1">Constraints</dt>
5422 <dd>
5423 <p><code>T</code> is an array of unknown bounds.</p>
5424 </dd>
5425 <dt class="hdlist1">Returns</dt>
5426 <dd>
5427 <p>A <code>std::unique_ptr</code> to a sequence of <code>n</code> objects of type
5428 <code>remove_extent_t&lt;T&gt;</code>, each initialized to <code>v</code>.</p>
5429 </dd>
5430 <dt class="hdlist1">Examples</dt>
5431 </dl>
5432 </div>
5433 </li>
5434 <li>
5435 <p><code>auto p = allocate_unique&lt;double[]&gt;(a, 1024, 1.0);</code></p>
5436 </li>
5437 <li>
5438 <p><code>auto p = allocate_unique&lt;double[][2]&gt;(a, 6, {1.0, 0.0});</code></p>
5439 </li>
5440 <li>
5441 <p><code>auto p = allocate_unique&lt;std::vector&lt;int&gt;[]&gt;(a, 4, {1, 2});</code></p>
5442 </li>
5443 </ul>
5444 </div>
5445 <div class="listingblock">
5446 <div class="content">
5447 <pre class="highlight"><code>template&lt;class T, class A&gt;
5448   std::unique_ptr&lt;remove_extent_t&lt;T&gt;[], alloc_deleter&lt;T, A&gt;&gt;
5449     allocate_unique(const A&amp; a, const remove_extent_t&lt;T&gt;&amp; v);</code></pre>
5450 </div>
5451 </div>
5452 <div class="ulist none">
5453 <ul class="none">
5454 <li>
5455 <p></p>
5456 <div class="dlist">
5457 <dl>
5458 <dt class="hdlist1">Constraints</dt>
5459 <dd>
5460 <p><code>T</code> is an array of known bounds.</p>
5461 </dd>
5462 <dt class="hdlist1">Returns</dt>
5463 <dd>
5464 <p>A <code>std::unique_ptr</code> to a sequence of <code>extent_v&lt;T&gt;</code> objects of type
5465 <code>remove_extent_t&lt;T&gt;</code>, each initialized to <code>v</code>.</p>
5466 </dd>
5467 <dt class="hdlist1">Examples</dt>
5468 </dl>
5469 </div>
5470 </li>
5471 <li>
5472 <p><code>auto p = allocate_unique&lt;double[1024]&gt;(a, 1.0);</code></p>
5473 </li>
5474 <li>
5475 <p><code>auto p = allocate_unique&lt;double[6][2]&gt;(a, {1.0, 0.0});</code></p>
5476 </li>
5477 <li>
5478 <p><code>auto p = allocate_unique&lt;std::vector&lt;int&gt;[4]&gt;(a, {1, 2});</code></p>
5479 </li>
5480 </ul>
5481 </div>
5482 <div class="listingblock">
5483 <div class="content">
5484 <pre class="highlight"><code>template&lt;class T, class A&gt;
5485   std::unique_ptr&lt;T, alloc_noinit_deleter&lt;T, A&gt;&gt;
5486     allocate_unique_noinit(const A&amp; a);</code></pre>
5487 </div>
5488 </div>
5489 <div class="ulist none">
5490 <ul class="none">
5491 <li>
5492 <p></p>
5493 <div class="dlist">
5494 <dl>
5495 <dt class="hdlist1">Constraints</dt>
5496 <dd>
5497 <p><code>T</code> is not an array.</p>
5498 </dd>
5499 <dt class="hdlist1">Returns</dt>
5500 <dd>
5501 <p>A <code>std::unique_ptr</code> to a default-initialized object of type <code>T</code>.</p>
5502 </dd>
5503 <dt class="hdlist1">Example</dt>
5504 <dd>
5505 <p><code>auto p = allocate_unique_noinit&lt;double&gt;(a);</code></p>
5506 </dd>
5507 </dl>
5508 </div>
5509 </li>
5510 </ul>
5511 </div>
5512 <div class="listingblock">
5513 <div class="content">
5514 <pre class="highlight"><code>template&lt;class T, class A&gt;
5515   std::unique_ptr&lt;T, alloc_noinit_deleter&lt;T, A&gt;&gt;
5516     allocate_unique_noinit(const A&amp; a, std::size_t n);</code></pre>
5517 </div>
5518 </div>
5519 <div class="ulist none">
5520 <ul class="none">
5521 <li>
5522 <p></p>
5523 <div class="dlist">
5524 <dl>
5525 <dt class="hdlist1">Constraints</dt>
5526 <dd>
5527 <p><code>T</code> is an array of unknown bounds.</p>
5528 </dd>
5529 <dt class="hdlist1">Returns</dt>
5530 <dd>
5531 <p>A <code>std::unique_ptr</code> to a sequence of <code>n</code> default-initialized objects
5532 of type <code>remove_extent_t&lt;T&gt;</code>.</p>
5533 </dd>
5534 <dt class="hdlist1">Example</dt>
5535 <dd>
5536 <p><code>auto p = allocate_unique_noinit&lt;double[]&gt;(a, 1024);</code></p>
5537 </dd>
5538 </dl>
5539 </div>
5540 </li>
5541 </ul>
5542 </div>
5543 <div class="listingblock">
5544 <div class="content">
5545 <pre class="highlight"><code>template&lt;class T, class A&gt;
5546   std::unique_ptr&lt;remove_extent_t&lt;T&gt;, alloc_noinit_deleter&lt;T, A&gt;&gt;
5547     allocate_unique_noinit(const A&amp; a);</code></pre>
5548 </div>
5549 </div>
5550 <div class="ulist none">
5551 <ul class="none">
5552 <li>
5553 <p></p>
5554 <div class="dlist">
5555 <dl>
5556 <dt class="hdlist1">Constraints</dt>
5557 <dd>
5558 <p><code>T</code> is an array of known bounds.</p>
5559 </dd>
5560 <dt class="hdlist1">Returns</dt>
5561 <dd>
5562 <p>A <code>std::unique_ptr</code> to a sequence of <code>extent_v&lt;T&gt;</code>
5563 default-initialized objects of type <code>remove_extent_t&lt;T&gt;</code>.</p>
5564 </dd>
5565 <dt class="hdlist1">Example</dt>
5566 <dd>
5567 <p><code>auto p = allocate_unique_noinit&lt;double[1024]&gt;(a);</code></p>
5568 </dd>
5569 </dl>
5570 </div>
5571 </li>
5572 </ul>
5573 </div>
5574 </div>
5575 <div class="sect2">
5576 <h3 id="allocate_unique_deleter">Deleter</h3>
5577 <div class="paragraph">
5578 <p>Class template <code>alloc_deleter</code> is the deleter used by the <code>allocate_unique</code>
5579 functions.</p>
5580 </div>
5581 <div class="sect3">
5582 <h4 id="allocate_unique_synopsis_2">Synopsis</h4>
5583 <div class="listingblock">
5584 <div class="content">
5585 <pre class="highlight"><code>template&lt;class T, class A&gt;
5586 class alloc_deleter {
5587 public:
5588   using pointer = <code>unspecified</code>;
5589
5590   explicit alloc_deleter(const A&amp; a) noexcept;
5591
5592   void operator()(pointer p);
5593 };</code></pre>
5594 </div>
5595 </div>
5596 </div>
5597 <div class="sect3">
5598 <h4 id="allocate_unique_members">Members</h4>
5599 <div class="listingblock">
5600 <div class="content">
5601 <pre class="highlight"><code>using pointer = <code>unspecified</code>;</code></pre>
5602 </div>
5603 </div>
5604 <div class="ulist none">
5605 <ul class="none">
5606 <li>
5607 <p></p>
5608 <div class="paragraph">
5609 <p>A type that satisfies <em>NullablePointer</em>.</p>
5610 </div>
5611 </li>
5612 </ul>
5613 </div>
5614 <div class="listingblock">
5615 <div class="content">
5616 <pre class="highlight"><code>explicit alloc_deleter(const A&amp; a) noexcept;</code></pre>
5617 </div>
5618 </div>
5619 <div class="ulist none">
5620 <ul class="none">
5621 <li>
5622 <p></p>
5623 <div class="dlist">
5624 <dl>
5625 <dt class="hdlist1">Effects</dt>
5626 <dd>
5627 <p>Initializes the stored allocator from <code>a</code>.</p>
5628 </dd>
5629 </dl>
5630 </div>
5631 </li>
5632 </ul>
5633 </div>
5634 <div class="listingblock">
5635 <div class="content">
5636 <pre class="highlight"><code>void operator()(pointer p);</code></pre>
5637 </div>
5638 </div>
5639 <div class="ulist none">
5640 <ul class="none">
5641 <li>
5642 <p></p>
5643 <div class="dlist">
5644 <dl>
5645 <dt class="hdlist1">Effects</dt>
5646 <dd>
5647 <p>Destroys the objects and deallocates the storage referenced by <code>p</code>,
5648 using the stored allocator.</p>
5649 </dd>
5650 </dl>
5651 </div>
5652 </li>
5653 </ul>
5654 </div>
5655 </div>
5656 </div>
5657 </div>
5658 </div>
5659 <div class="sect1">
5660 <h2 id="intrusive_ptr">intrusive_ptr: Managing Objects with Embedded Counts</h2>
5661 <div class="sectionbody">
5662 <div class="sect2">
5663 <h3 id="intrusive_ptr_description">Description</h3>
5664 <div class="paragraph">
5665 <p>The <code>intrusive_ptr</code> class template stores a pointer to an object with an embedded reference count.
5666 Every new <code>intrusive_ptr</code> instance increments the reference count by using an unqualified call to the
5667 function <code>intrusive_ptr_add_ref</code>, passing it the pointer as an argument. Similarly, when an <code>intrusive_ptr</code>
5668 is destroyed, it calls <code>intrusive_ptr_release</code>; this function is responsible for destroying the object when
5669 its reference count drops to zero. The user is expected to provide suitable definitions of these two functions.
5670 On compilers that support argument-dependent lookup, <code>intrusive_ptr_add_ref</code> and <code>intrusive_ptr_release</code> should
5671 be defined in the namespace that corresponds to their parameter; otherwise, the definitions need to go in namespace
5672 <code>boost</code>. The library provides a helper base class template <code><a href="#intrusive_ref_counter">intrusive_ref_counter</a></code> which
5673 may help adding support for <code>intrusive_ptr</code> to user types.</p>
5674 </div>
5675 <div class="paragraph">
5676 <p>The class template is parameterized on <code>T</code>, the type of the object pointed to. <code>intrusive_ptr&lt;T&gt;</code> can be implicitly
5677 converted to <code>intrusive_ptr&lt;U&gt;</code> whenever <code>T*</code> can be implicitly converted to <code>U*</code>.</p>
5678 </div>
5679 <div class="paragraph">
5680 <p>The main reasons to use <code>intrusive_ptr</code> are:</p>
5681 </div>
5682 <div class="ulist">
5683 <ul>
5684 <li>
5685 <p>Some existing frameworks or OSes provide objects with embedded reference counts;</p>
5686 </li>
5687 <li>
5688 <p>The memory footprint of <code>intrusive_ptr</code> is the same as the corresponding raw pointer;</p>
5689 </li>
5690 <li>
5691 <p><code>intrusive_ptr&lt;T&gt;</code> can be constructed from an arbitrary raw pointer of type <code>T*</code>.</p>
5692 </li>
5693 </ul>
5694 </div>
5695 <div class="paragraph">
5696 <p>As a general rule, if it isn&#8217;t obvious whether <code>intrusive_ptr</code> better fits your needs than <code>shared_ptr</code>, try a <code>shared_ptr</code>-based design first.</p>
5697 </div>
5698 </div>
5699 <div class="sect2">
5700 <h3 id="intrusive_ptr_synopsis">Synopsis</h3>
5701 <div class="paragraph">
5702 <p><code>intrusive_ptr</code> is defined in <code>&lt;boost/smart_ptr/intrusive_ptr.hpp&gt;</code>.</p>
5703 </div>
5704 <div class="listingblock">
5705 <div class="content">
5706 <pre class="highlight"><code>namespace boost {
5707
5708   template&lt;class T&gt; class intrusive_ptr {
5709   public:
5710
5711     typedef T element_type;
5712
5713     intrusive_ptr() noexcept;
5714     intrusive_ptr(T * p, bool add_ref = true);
5715
5716     intrusive_ptr(intrusive_ptr const &amp; r);
5717     template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; const &amp; r);
5718
5719     intrusive_ptr(intrusive_ptr &amp;&amp; r);
5720     template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; &amp;&amp; r);
5721
5722     ~intrusive_ptr();
5723
5724     intrusive_ptr &amp; operator=(intrusive_ptr const &amp; r);
5725     template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; const &amp; r);
5726     intrusive_ptr &amp; operator=(T * r);
5727
5728     intrusive_ptr &amp; operator=(intrusive_ptr &amp;&amp; r);
5729     template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; &amp;&amp; r);
5730
5731     void reset();
5732     void reset(T * r);
5733     void reset(T * r, bool add_ref);
5734
5735     T &amp; operator*() const noexcept;
5736     T * operator-&gt;() const noexcept;
5737     T * get() const noexcept;
5738     T * detach() noexcept;
5739
5740     explicit operator bool () const noexcept;
5741
5742     void swap(intrusive_ptr &amp; b) noexcept;
5743   };
5744
5745   template&lt;class T, class U&gt;
5746     bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;
5747
5748   template&lt;class T, class U&gt;
5749     bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;
5750
5751   template&lt;class T, class U&gt;
5752     bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, U * b) noexcept;
5753
5754   template&lt;class T, class U&gt;
5755     bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, U * b) noexcept;
5756
5757   template&lt;class T, class U&gt;
5758     bool operator==(T * a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;
5759
5760   template&lt;class T, class U&gt;
5761     bool operator!=(T * a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;
5762
5763   template&lt;class T&gt;
5764     bool operator&lt;(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;T&gt; const &amp; b) noexcept;
5765
5766   template&lt;class T&gt; void swap(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b) noexcept;
5767
5768   template&lt;class T&gt; T * get_pointer(intrusive_ptr&lt;T&gt; const &amp; p) noexcept;
5769
5770   template&lt;class T, class U&gt;
5771     intrusive_ptr&lt;T&gt; static_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r) noexcept;
5772
5773   template&lt;class T, class U&gt;
5774     intrusive_ptr&lt;T&gt; const_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r) noexcept;
5775
5776   template&lt;class T, class U&gt;
5777     intrusive_ptr&lt;T&gt; dynamic_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r) noexcept;
5778
5779   template&lt;class E, class T, class Y&gt;
5780     std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os,
5781       intrusive_ptr&lt;Y&gt; const &amp; p);
5782 }</code></pre>
5783 </div>
5784 </div>
5785 </div>
5786 <div class="sect2">
5787 <h3 id="intrusive_ptr_members">Members</h3>
5788 <div class="sect3">
5789 <h4 id="intrusive_ptr_element_type">element_type</h4>
5790 <div class="listingblock">
5791 <div class="content">
5792 <pre class="highlight"><code>typedef T element_type;</code></pre>
5793 </div>
5794 </div>
5795 <div class="paragraph">
5796 <p>Provides the type of the template parameter T.</p>
5797 </div>
5798 </div>
5799 <div class="sect3">
5800 <h4 id="intrusive_ptr_constructors">constructors</h4>
5801 <div class="listingblock">
5802 <div class="content">
5803 <pre class="highlight"><code>intrusive_ptr() noexcept;</code></pre>
5804 </div>
5805 </div>
5806 <div class="ulist none">
5807 <ul class="none">
5808 <li>
5809 <p></p>
5810 <div class="dlist">
5811 <dl>
5812 <dt class="hdlist1">Postconditions</dt>
5813 <dd>
5814 <p><code>get() == 0</code>.</p>
5815 </dd>
5816 </dl>
5817 </div>
5818 </li>
5819 </ul>
5820 </div>
5821 <div class="listingblock">
5822 <div class="content">
5823 <pre class="highlight"><code>intrusive_ptr(T * p, bool add_ref = true);</code></pre>
5824 </div>
5825 </div>
5826 <div class="ulist none">
5827 <ul class="none">
5828 <li>
5829 <p></p>
5830 <div class="dlist">
5831 <dl>
5832 <dt class="hdlist1">Effects</dt>
5833 <dd>
5834 <p><code>if(p != 0 &amp;&amp; add_ref) intrusive_ptr_add_ref(p);</code>.</p>
5835 </dd>
5836 <dt class="hdlist1">Postconditions</dt>
5837 <dd>
5838 <p><code>get() == p</code>.</p>
5839 </dd>
5840 </dl>
5841 </div>
5842 </li>
5843 </ul>
5844 </div>
5845 <div class="listingblock">
5846 <div class="content">
5847 <pre class="highlight"><code>intrusive_ptr(intrusive_ptr const &amp; r);</code></pre>
5848 </div>
5849 </div>
5850 <div class="listingblock">
5851 <div class="content">
5852 <pre class="highlight"><code>template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; const &amp; r);</code></pre>
5853 </div>
5854 </div>
5855 <div class="ulist none">
5856 <ul class="none">
5857 <li>
5858 <p></p>
5859 <div class="dlist">
5860 <dl>
5861 <dt class="hdlist1">Effects</dt>
5862 <dd>
5863 <p><code>T * p = r.get(); if(p != 0) intrusive_ptr_add_ref(p);</code>.</p>
5864 </dd>
5865 <dt class="hdlist1">Postconditions</dt>
5866 <dd>
5867 <p><code>get() == r.get()</code>.</p>
5868 </dd>
5869 </dl>
5870 </div>
5871 </li>
5872 </ul>
5873 </div>
5874 <div class="listingblock">
5875 <div class="content">
5876 <pre class="highlight"><code>intrusive_ptr(intrusive_ptr &amp;&amp; r);</code></pre>
5877 </div>
5878 </div>
5879 <div class="listingblock">
5880 <div class="content">
5881 <pre class="highlight"><code>template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; &amp;&amp; r);</code></pre>
5882 </div>
5883 </div>
5884 <div class="ulist none">
5885 <ul class="none">
5886 <li>
5887 <p></p>
5888 <div class="dlist">
5889 <dl>
5890 <dt class="hdlist1">Postconditions</dt>
5891 <dd>
5892 <p><code>get()</code> equals the old value of <code>r.get()</code>. <code>r.get() == 0</code>.</p>
5893 </dd>
5894 </dl>
5895 </div>
5896 </li>
5897 </ul>
5898 </div>
5899 </div>
5900 <div class="sect3">
5901 <h4 id="intrusive_ptr_destructor">destructor</h4>
5902 <div class="listingblock">
5903 <div class="content">
5904 <pre class="highlight"><code>~intrusive_ptr();</code></pre>
5905 </div>
5906 </div>
5907 <div class="ulist none">
5908 <ul class="none">
5909 <li>
5910 <p></p>
5911 <div class="dlist">
5912 <dl>
5913 <dt class="hdlist1">Effects</dt>
5914 <dd>
5915 <p><code>if(get() != 0) intrusive_ptr_release(get());</code>.</p>
5916 </dd>
5917 </dl>
5918 </div>
5919 </li>
5920 </ul>
5921 </div>
5922 </div>
5923 <div class="sect3">
5924 <h4 id="intrusive_ptr_assignment">assignment</h4>
5925 <div class="listingblock">
5926 <div class="content">
5927 <pre class="highlight"><code>intrusive_ptr &amp; operator=(intrusive_ptr const &amp; r);</code></pre>
5928 </div>
5929 </div>
5930 <div class="listingblock">
5931 <div class="content">
5932 <pre class="highlight"><code>template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; const &amp; r);</code></pre>
5933 </div>
5934 </div>
5935 <div class="listingblock">
5936 <div class="content">
5937 <pre class="highlight"><code>intrusive_ptr &amp; operator=(T * r);</code></pre>
5938 </div>
5939 </div>
5940 <div class="ulist none">
5941 <ul class="none">
5942 <li>
5943 <p></p>
5944 <div class="dlist">
5945 <dl>
5946 <dt class="hdlist1">Effects</dt>
5947 <dd>
5948 <p>Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</p>
5949 </dd>
5950 <dt class="hdlist1">Returns</dt>
5951 <dd>
5952 <p><code>*this</code>.</p>
5953 </dd>
5954 </dl>
5955 </div>
5956 </li>
5957 </ul>
5958 </div>
5959 <div class="listingblock">
5960 <div class="content">
5961 <pre class="highlight"><code>intrusive_ptr &amp; operator=(intrusive_ptr &amp;&amp; r);</code></pre>
5962 </div>
5963 </div>
5964 <div class="listingblock">
5965 <div class="content">
5966 <pre class="highlight"><code>template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; &amp;&amp; r);</code></pre>
5967 </div>
5968 </div>
5969 <div class="ulist none">
5970 <ul class="none">
5971 <li>
5972 <p></p>
5973 <div class="dlist">
5974 <dl>
5975 <dt class="hdlist1">Effects</dt>
5976 <dd>
5977 <p>Equivalent to <code>intrusive_ptr(std::move(r)).swap(*this)</code>.</p>
5978 </dd>
5979 <dt class="hdlist1">Returns</dt>
5980 <dd>
5981 <p><code>*this</code>.</p>
5982 </dd>
5983 </dl>
5984 </div>
5985 </li>
5986 </ul>
5987 </div>
5988 </div>
5989 <div class="sect3">
5990 <h4 id="intrusive_ptr_reset">reset</h4>
5991 <div class="listingblock">
5992 <div class="content">
5993 <pre class="highlight"><code>void reset();</code></pre>
5994 </div>
5995 </div>
5996 <div class="ulist none">
5997 <ul class="none">
5998 <li>
5999 <p></p>
6000 <div class="dlist">
6001 <dl>
6002 <dt class="hdlist1">Effects</dt>
6003 <dd>
6004 <p>Equivalent to <code>intrusive_ptr().swap(*this)</code>.</p>
6005 </dd>
6006 </dl>
6007 </div>
6008 </li>
6009 </ul>
6010 </div>
6011 <div class="listingblock">
6012 <div class="content">
6013 <pre class="highlight"><code>void reset(T * r);</code></pre>
6014 </div>
6015 </div>
6016 <div class="ulist none">
6017 <ul class="none">
6018 <li>
6019 <p></p>
6020 <div class="dlist">
6021 <dl>
6022 <dt class="hdlist1">Effects</dt>
6023 <dd>
6024 <p>Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</p>
6025 </dd>
6026 </dl>
6027 </div>
6028 </li>
6029 </ul>
6030 </div>
6031 <div class="listingblock">
6032 <div class="content">
6033 <pre class="highlight"><code>void reset(T * r, bool add_ref);</code></pre>
6034 </div>
6035 </div>
6036 <div class="ulist none">
6037 <ul class="none">
6038 <li>
6039 <p></p>
6040 <div class="dlist">
6041 <dl>
6042 <dt class="hdlist1">Effects</dt>
6043 <dd>
6044 <p>Equivalent to <code>intrusive_ptr(r, add_ref).swap(*this)</code>.</p>
6045 </dd>
6046 </dl>
6047 </div>
6048 </li>
6049 </ul>
6050 </div>
6051 </div>
6052 <div class="sect3">
6053 <h4 id="intrusive_ptr_indirection">indirection</h4>
6054 <div class="listingblock">
6055 <div class="content">
6056 <pre class="highlight"><code>T &amp; operator*() const noexcept;</code></pre>
6057 </div>
6058 </div>
6059 <div class="ulist none">
6060 <ul class="none">
6061 <li>
6062 <p></p>
6063 <div class="dlist">
6064 <dl>
6065 <dt class="hdlist1">Requirements</dt>
6066 <dd>
6067 <p><code>get() != 0</code>.</p>
6068 </dd>
6069 <dt class="hdlist1">Returns</dt>
6070 <dd>
6071 <p><code>*get()</code>.</p>
6072 </dd>
6073 </dl>
6074 </div>
6075 </li>
6076 </ul>
6077 </div>
6078 <div class="listingblock">
6079 <div class="content">
6080 <pre class="highlight"><code>T * operator-&gt;() const noexcept;</code></pre>
6081 </div>
6082 </div>
6083 <div class="ulist none">
6084 <ul class="none">
6085 <li>
6086 <p></p>
6087 <div class="dlist">
6088 <dl>
6089 <dt class="hdlist1">Requirements</dt>
6090 <dd>
6091 <p><code>get() != 0</code>.</p>
6092 </dd>
6093 <dt class="hdlist1">Returns</dt>
6094 <dd>
6095 <p><code>get()</code>.</p>
6096 </dd>
6097 </dl>
6098 </div>
6099 </li>
6100 </ul>
6101 </div>
6102 </div>
6103 <div class="sect3">
6104 <h4 id="intrusive_ptr_get">get</h4>
6105 <div class="listingblock">
6106 <div class="content">
6107 <pre class="highlight"><code>T * get() const noexcept;</code></pre>
6108 </div>
6109 </div>
6110 <div class="ulist none">
6111 <ul class="none">
6112 <li>
6113 <p></p>
6114 <div class="dlist">
6115 <dl>
6116 <dt class="hdlist1">Returns</dt>
6117 <dd>
6118 <p>the stored pointer.</p>
6119 </dd>
6120 </dl>
6121 </div>
6122 </li>
6123 </ul>
6124 </div>
6125 </div>
6126 <div class="sect3">
6127 <h4 id="intrusive_ptr_detach">detach</h4>
6128 <div class="listingblock">
6129 <div class="content">
6130 <pre class="highlight"><code>T * detach() noexcept;</code></pre>
6131 </div>
6132 </div>
6133 <div class="ulist none">
6134 <ul class="none">
6135 <li>
6136 <p></p>
6137 <div class="dlist">
6138 <dl>
6139 <dt class="hdlist1">Returns</dt>
6140 <dd>
6141 <p>the stored pointer.</p>
6142 </dd>
6143 <dt class="hdlist1">Postconditions</dt>
6144 <dd>
6145 <p><code>get() == 0</code>.</p>
6146 </dd>
6147 </dl>
6148 </div>
6149 </li>
6150 </ul>
6151 </div>
6152 <div class="admonitionblock note">
6153 <table>
6154 <tr>
6155 <td class="icon">
6156 <div class="title">Note</div>
6157 </td>
6158 <td class="content">
6159 The returned pointer has an elevated reference count. This allows conversion of an <code>intrusive_ptr</code>
6160 back to a raw pointer, without the performance overhead of acquiring and dropping an extra reference.
6161 It can be viewed as the complement of the non-reference-incrementing constructor.
6162 </td>
6163 </tr>
6164 </table>
6165 </div>
6166 <div class="admonitionblock caution">
6167 <table>
6168 <tr>
6169 <td class="icon">
6170 <div class="title">Caution</div>
6171 </td>
6172 <td class="content">
6173 Using <code>detach</code> escapes the safety of automatic reference counting provided by <code>intrusive_ptr</code>.
6174 It should by used only where strictly necessary (such as when interfacing to an existing API), and when
6175 the implications are thoroughly understood.
6176 </td>
6177 </tr>
6178 </table>
6179 </div>
6180 </div>
6181 <div class="sect3">
6182 <h4 id="intrusive_ptr_conversions">conversions</h4>
6183 <div class="listingblock">
6184 <div class="content">
6185 <pre class="highlight"><code>explicit operator bool () const noexcept;</code></pre>
6186 </div>
6187 </div>
6188 <div class="ulist none">
6189 <ul class="none">
6190 <li>
6191 <p></p>
6192 <div class="dlist">
6193 <dl>
6194 <dt class="hdlist1">Returns</dt>
6195 <dd>
6196 <p><code>get() != 0</code>.</p>
6197 </dd>
6198 </dl>
6199 </div>
6200 </li>
6201 </ul>
6202 </div>
6203 <div class="admonitionblock note">
6204 <table>
6205 <tr>
6206 <td class="icon">
6207 <div class="title">Note</div>
6208 </td>
6209 <td class="content">
6210 This conversion operator allows <code>intrusive_ptr</code> objects to be used in boolean contexts,
6211 like <code>if (p &amp;&amp; p-&gt;valid()) {}</code>.
6212 </td>
6213 </tr>
6214 </table>
6215 </div>
6216 <div class="admonitionblock note">
6217 <table>
6218 <tr>
6219 <td class="icon">
6220 <div class="title">Note</div>
6221 </td>
6222 <td class="content">
6223 On C++03 compilers, the return value is of an unspecified type.
6224 </td>
6225 </tr>
6226 </table>
6227 </div>
6228 </div>
6229 <div class="sect3">
6230 <h4 id="intrusive_ptr_swap">swap</h4>
6231 <div class="listingblock">
6232 <div class="content">
6233 <pre class="highlight"><code>void swap(intrusive_ptr &amp; b) noexcept;</code></pre>
6234 </div>
6235 </div>
6236 <div class="ulist none">
6237 <ul class="none">
6238 <li>
6239 <p></p>
6240 <div class="dlist">
6241 <dl>
6242 <dt class="hdlist1">Effects</dt>
6243 <dd>
6244 <p>Exchanges the contents of the two smart pointers.</p>
6245 </dd>
6246 </dl>
6247 </div>
6248 </li>
6249 </ul>
6250 </div>
6251 </div>
6252 </div>
6253 <div class="sect2">
6254 <h3 id="intrusive_ptr_free_functions">Free Functions</h3>
6255 <div class="sect3">
6256 <h4 id="intrusive_ptr_comparison">comparison</h4>
6257 <div class="listingblock">
6258 <div class="content">
6259 <pre class="highlight"><code>template&lt;class T, class U&gt;
6260   bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
6261 </div>
6262 </div>
6263 <div class="ulist none">
6264 <ul class="none">
6265 <li>
6266 <p></p>
6267 <div class="dlist">
6268 <dl>
6269 <dt class="hdlist1">Returns</dt>
6270 <dd>
6271 <p><code>a.get() == b.get()</code>.</p>
6272 </dd>
6273 </dl>
6274 </div>
6275 </li>
6276 </ul>
6277 </div>
6278 <div class="listingblock">
6279 <div class="content">
6280 <pre class="highlight"><code>template&lt;class T, class U&gt;
6281   bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
6282 </div>
6283 </div>
6284 <div class="ulist none">
6285 <ul class="none">
6286 <li>
6287 <p></p>
6288 <div class="dlist">
6289 <dl>
6290 <dt class="hdlist1">Returns</dt>
6291 <dd>
6292 <p><code>a.get() != b.get()</code>.</p>
6293 </dd>
6294 </dl>
6295 </div>
6296 </li>
6297 </ul>
6298 </div>
6299 <div class="listingblock">
6300 <div class="content">
6301 <pre class="highlight"><code>template&lt;class T, class U&gt;
6302   bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, U * b) noexcept;</code></pre>
6303 </div>
6304 </div>
6305 <div class="ulist none">
6306 <ul class="none">
6307 <li>
6308 <p></p>
6309 <div class="dlist">
6310 <dl>
6311 <dt class="hdlist1">Returns</dt>
6312 <dd>
6313 <p><code>a.get() == b</code>.</p>
6314 </dd>
6315 </dl>
6316 </div>
6317 </li>
6318 </ul>
6319 </div>
6320 <div class="listingblock">
6321 <div class="content">
6322 <pre class="highlight"><code>template&lt;class T, class U&gt;
6323   bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, U * b) noexcept;</code></pre>
6324 </div>
6325 </div>
6326 <div class="ulist none">
6327 <ul class="none">
6328 <li>
6329 <p></p>
6330 <div class="dlist">
6331 <dl>
6332 <dt class="hdlist1">Returns</dt>
6333 <dd>
6334 <p><code>a.get() != b</code>.</p>
6335 </dd>
6336 </dl>
6337 </div>
6338 </li>
6339 </ul>
6340 </div>
6341 <div class="listingblock">
6342 <div class="content">
6343 <pre class="highlight"><code>template&lt;class T, class U&gt;
6344   bool operator==(T * a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
6345 </div>
6346 </div>
6347 <div class="ulist none">
6348 <ul class="none">
6349 <li>
6350 <p></p>
6351 <div class="dlist">
6352 <dl>
6353 <dt class="hdlist1">Returns</dt>
6354 <dd>
6355 <p><code>a == b.get()</code>.</p>
6356 </dd>
6357 </dl>
6358 </div>
6359 </li>
6360 </ul>
6361 </div>
6362 <div class="listingblock">
6363 <div class="content">
6364 <pre class="highlight"><code>template&lt;class T, class U&gt;
6365   bool operator!=(T * a, intrusive_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
6366 </div>
6367 </div>
6368 <div class="ulist none">
6369 <ul class="none">
6370 <li>
6371 <p></p>
6372 <div class="dlist">
6373 <dl>
6374 <dt class="hdlist1">Returns</dt>
6375 <dd>
6376 <p><code>a != b.get()</code>.</p>
6377 </dd>
6378 </dl>
6379 </div>
6380 </li>
6381 </ul>
6382 </div>
6383 <div class="listingblock">
6384 <div class="content">
6385 <pre class="highlight"><code>template&lt;class T&gt;
6386   bool operator&lt;(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;T&gt; const &amp; b) noexcept;</code></pre>
6387 </div>
6388 </div>
6389 <div class="ulist none">
6390 <ul class="none">
6391 <li>
6392 <p></p>
6393 <div class="dlist">
6394 <dl>
6395 <dt class="hdlist1">Returns</dt>
6396 <dd>
6397 <p><code>std::less&lt;T *&gt;()(a.get(), b.get())</code>.</p>
6398 </dd>
6399 </dl>
6400 </div>
6401 </li>
6402 </ul>
6403 </div>
6404 <div class="admonitionblock note">
6405 <table>
6406 <tr>
6407 <td class="icon">
6408 <div class="title">Note</div>
6409 </td>
6410 <td class="content">
6411 Allows <code>intrusive_ptr</code> objects to be used as keys in associative containers.
6412 </td>
6413 </tr>
6414 </table>
6415 </div>
6416 </div>
6417 <div class="sect3">
6418 <h4 id="intrusive_ptr_swap_2">swap</h4>
6419 <div class="listingblock">
6420 <div class="content">
6421 <pre class="highlight"><code>template&lt;class T&gt; void swap(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b) noexcept;</code></pre>
6422 </div>
6423 </div>
6424 <div class="ulist none">
6425 <ul class="none">
6426 <li>
6427 <p></p>
6428 <div class="dlist">
6429 <dl>
6430 <dt class="hdlist1">Effects</dt>
6431 <dd>
6432 <p>Equivalent to <code>a.swap(b)</code>.</p>
6433 </dd>
6434 </dl>
6435 </div>
6436 </li>
6437 </ul>
6438 </div>
6439 </div>
6440 <div class="sect3">
6441 <h4 id="intrusive_ptr_get_pointer">get_pointer</h4>
6442 <div class="listingblock">
6443 <div class="content">
6444 <pre class="highlight"><code>template&lt;class T&gt; T * get_pointer(intrusive_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
6445 </div>
6446 </div>
6447 <div class="ulist none">
6448 <ul class="none">
6449 <li>
6450 <p></p>
6451 <div class="dlist">
6452 <dl>
6453 <dt class="hdlist1">Returns</dt>
6454 <dd>
6455 <p><code>p.get()</code>.</p>
6456 </dd>
6457 </dl>
6458 </div>
6459 </li>
6460 </ul>
6461 </div>
6462 <div class="admonitionblock note">
6463 <table>
6464 <tr>
6465 <td class="icon">
6466 <div class="title">Note</div>
6467 </td>
6468 <td class="content">
6469 Provided as an aid to generic programming. Used by <code>mem_fn</code>.
6470 </td>
6471 </tr>
6472 </table>
6473 </div>
6474 </div>
6475 <div class="sect3">
6476 <h4 id="intrusive_ptr_static_pointer_cast">static_pointer_cast</h4>
6477 <div class="listingblock">
6478 <div class="content">
6479 <pre class="highlight"><code>template&lt;class T, class U&gt;
6480   intrusive_ptr&lt;T&gt; static_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
6481 </div>
6482 </div>
6483 <div class="ulist none">
6484 <ul class="none">
6485 <li>
6486 <p></p>
6487 <div class="dlist">
6488 <dl>
6489 <dt class="hdlist1">Returns</dt>
6490 <dd>
6491 <p><code>intrusive_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>.</p>
6492 </dd>
6493 </dl>
6494 </div>
6495 </li>
6496 </ul>
6497 </div>
6498 </div>
6499 <div class="sect3">
6500 <h4 id="intrusive_ptr_const_pointer_cast">const_pointer_cast</h4>
6501 <div class="listingblock">
6502 <div class="content">
6503 <pre class="highlight"><code>template&lt;class T, class U&gt;
6504   intrusive_ptr&lt;T&gt; const_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
6505 </div>
6506 </div>
6507 <div class="ulist none">
6508 <ul class="none">
6509 <li>
6510 <p></p>
6511 <div class="dlist">
6512 <dl>
6513 <dt class="hdlist1">Returns</dt>
6514 <dd>
6515 <p><code>intrusive_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code>.</p>
6516 </dd>
6517 </dl>
6518 </div>
6519 </li>
6520 </ul>
6521 </div>
6522 </div>
6523 <div class="sect3">
6524 <h4 id="intrusive_ptr_dynamic_pointer_cast">dynamic_pointer_cast</h4>
6525 <div class="listingblock">
6526 <div class="content">
6527 <pre class="highlight"><code>template&lt;class T, class U&gt;
6528   intrusive_ptr&lt;T&gt; dynamic_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
6529 </div>
6530 </div>
6531 <div class="ulist none">
6532 <ul class="none">
6533 <li>
6534 <p></p>
6535 <div class="dlist">
6536 <dl>
6537 <dt class="hdlist1">Returns</dt>
6538 <dd>
6539 <p><code>intrusive_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</code>.</p>
6540 </dd>
6541 </dl>
6542 </div>
6543 </li>
6544 </ul>
6545 </div>
6546 </div>
6547 <div class="sect3">
6548 <h4 id="intrusive_ptr_operator">operator&lt;&lt;</h4>
6549 <div class="listingblock">
6550 <div class="content">
6551 <pre class="highlight"><code>template&lt;class E, class T, class Y&gt;
6552   std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os,
6553     intrusive_ptr&lt;Y&gt; const &amp; p);</code></pre>
6554 </div>
6555 </div>
6556 <div class="ulist none">
6557 <ul class="none">
6558 <li>
6559 <p></p>
6560 <div class="dlist">
6561 <dl>
6562 <dt class="hdlist1">Effects</dt>
6563 <dd>
6564 <p><code>os &lt;&lt; p.get();</code>.</p>
6565 </dd>
6566 <dt class="hdlist1">Returns</dt>
6567 <dd>
6568 <p><code>os</code>.</p>
6569 </dd>
6570 </dl>
6571 </div>
6572 </li>
6573 </ul>
6574 </div>
6575 </div>
6576 </div>
6577 </div>
6578 </div>
6579 <div class="sect1">
6580 <h2 id="intrusive_ref_counter">intrusive_ref_counter</h2>
6581 <div class="sectionbody">
6582 <div class="sect2">
6583 <h3 id="intrusive_ref_counter_description">Description</h3>
6584 <div class="paragraph">
6585 <p>The <code>intrusive_ref_counter</code> class template implements a reference counter for
6586 a derived user&#8217;s class that is intended to be used with <code>intrusive_ptr</code>. The
6587 base class has associated <code>intrusive_ptr_add_ref</code> and <code>intrusive_ptr_release</code>
6588 functions which modify the reference counter as needed and destroy the user&#8217;s
6589 object when the counter drops to zero.</p>
6590 </div>
6591 <div class="paragraph">
6592 <p>The class template is parameterized on <code>Derived</code> and <code>CounterPolicy</code>
6593 parameters. The first parameter is the user&#8217;s class that derives from
6594 <code>intrusive_ref_counter</code>. This type is needed in order to destroy the object
6595 correctly when there are no references to it left.</p>
6596 </div>
6597 <div class="paragraph">
6598 <p>The second parameter is a policy that defines the nature of the reference
6599 counter. The library provides two such policies: <code>thread_unsafe_counter</code> and
6600 <code>thread_safe_counter</code>. The former instructs the <code>intrusive_ref_counter</code> base
6601 class to use a counter only suitable for a single-threaded use. Pointers to a
6602 single object that uses this kind of reference counter must not be used in
6603 different threads. The latter policy makes the reference counter thread-safe,
6604 unless the target platform doesn&#8217;t support threading. Since in modern systems
6605 support for threading is common, the default counter policy is
6606 <code>thread_safe_counter</code>.</p>
6607 </div>
6608 </div>
6609 <div class="sect2">
6610 <h3 id="intrusive_ref_counter_synopsis">Synopsis</h3>
6611 <div class="paragraph">
6612 <p><code>intrusive_ref_counter</code> is defined in
6613 <code>&lt;boost/smart_ptr/intrusive_ref_counter.hpp&gt;</code>.</p>
6614 </div>
6615 <div class="listingblock">
6616 <div class="content">
6617 <pre class="highlight"><code>namespace boost {
6618   struct thread_unsafe_counter;
6619   struct thread_safe_counter;
6620
6621   template&lt;class Derived, class CounterPolicy = thread_safe_counter&gt;
6622   class intrusive_ref_counter {
6623   public:
6624     intrusive_ref_counter() noexcept;
6625     intrusive_ref_counter(const intrusive_ref_counter&amp; v) noexcept;
6626
6627     intrusive_ref_counter&amp; operator=(const intrusive_ref_counter&amp; v) noexcept;
6628
6629     unsigned int use_count() const noexcept;
6630
6631   protected:
6632     ~intrusive_ref_counter() = default;
6633   };
6634
6635   template&lt;class Derived, class CounterPolicy&gt;
6636     void intrusive_ptr_add_ref(
6637       const intrusive_ref_counter&lt;Derived, CounterPolicy&gt;* p) noexcept;
6638
6639   template&lt;class Derived, class CounterPolicy&gt;
6640     void intrusive_ptr_release(
6641       const intrusive_ref_counter&lt;Derived, CounterPolicy&gt;* p) noexcept;
6642 }</code></pre>
6643 </div>
6644 </div>
6645 </div>
6646 <div class="sect2">
6647 <h3 id="intrusive_ref_counter_members">Members</h3>
6648 <div class="sect3">
6649 <h4 id="intrusive_ref_counter_constructors">Constructors</h4>
6650 <div class="listingblock">
6651 <div class="content">
6652 <pre class="highlight"><code>intrusive_ref_counter() noexcept;</code></pre>
6653 </div>
6654 </div>
6655 <div class="listingblock">
6656 <div class="content">
6657 <pre class="highlight"><code>intrusive_ref_counter(const intrusive_ref_counter&amp;) noexcept;</code></pre>
6658 </div>
6659 </div>
6660 <div class="ulist none">
6661 <ul class="none">
6662 <li>
6663 <p></p>
6664 <div class="dlist">
6665 <dl>
6666 <dt class="hdlist1">Postconditions</dt>
6667 <dd>
6668 <p><code>use_count() == 0</code>.</p>
6669 </dd>
6670 </dl>
6671 </div>
6672 </li>
6673 </ul>
6674 </div>
6675 <div class="admonitionblock note">
6676 <table>
6677 <tr>
6678 <td class="icon">
6679 <div class="title">Note</div>
6680 </td>
6681 <td class="content">
6682 The pointer to the constructed object is expected to be passed to
6683 <code>intrusive_ptr</code> constructor, assignment operator or <code>reset</code> method, which
6684 would increment the reference counter.
6685 </td>
6686 </tr>
6687 </table>
6688 </div>
6689 </div>
6690 <div class="sect3">
6691 <h4 id="intrusive_ref_counter_destructor">Destructor</h4>
6692 <div class="listingblock">
6693 <div class="content">
6694 <pre class="highlight"><code>~intrusive_ref_counter();</code></pre>
6695 </div>
6696 </div>
6697 <div class="ulist none">
6698 <ul class="none">
6699 <li>
6700 <p></p>
6701 <div class="dlist">
6702 <dl>
6703 <dt class="hdlist1">Effects</dt>
6704 <dd>
6705 <p>Destroys the counter object.</p>
6706 </dd>
6707 </dl>
6708 </div>
6709 </li>
6710 </ul>
6711 </div>
6712 <div class="admonitionblock note">
6713 <table>
6714 <tr>
6715 <td class="icon">
6716 <div class="title">Note</div>
6717 </td>
6718 <td class="content">
6719 The destructor is protected so that the object can only be destroyed
6720 through the <code>Derived</code> class.
6721 </td>
6722 </tr>
6723 </table>
6724 </div>
6725 </div>
6726 <div class="sect3">
6727 <h4 id="intrusive_ref_counter_assignment">Assignment</h4>
6728 <div class="listingblock">
6729 <div class="content">
6730 <pre class="highlight"><code>intrusive_ref_counter&amp; operator=(const intrusive_ref_counter&amp; v) noexcept;</code></pre>
6731 </div>
6732 </div>
6733 <div class="ulist none">
6734 <ul class="none">
6735 <li>
6736 <p></p>
6737 <div class="dlist">
6738 <dl>
6739 <dt class="hdlist1">Effects</dt>
6740 <dd>
6741 <p>Does nothing, reference counter is not modified.</p>
6742 </dd>
6743 </dl>
6744 </div>
6745 </li>
6746 </ul>
6747 </div>
6748 </div>
6749 <div class="sect3">
6750 <h4 id="intrusive_ref_counter_use_count">use_count</h4>
6751 <div class="listingblock">
6752 <div class="content">
6753 <pre class="highlight"><code>unsigned int use_count() const noexcept;</code></pre>
6754 </div>
6755 </div>
6756 <div class="ulist none">
6757 <ul class="none">
6758 <li>
6759 <p></p>
6760 <div class="dlist">
6761 <dl>
6762 <dt class="hdlist1">Returns</dt>
6763 <dd>
6764 <p>The current value of the reference counter.</p>
6765 </dd>
6766 </dl>
6767 </div>
6768 </li>
6769 </ul>
6770 </div>
6771 <div class="admonitionblock note">
6772 <table>
6773 <tr>
6774 <td class="icon">
6775 <div class="title">Note</div>
6776 </td>
6777 <td class="content">
6778 The returned value may not be actual in multi-threaded applications.
6779 </td>
6780 </tr>
6781 </table>
6782 </div>
6783 </div>
6784 </div>
6785 <div class="sect2">
6786 <h3 id="intrusive_ref_counter_free_functions">Free Functions</h3>
6787 <div class="sect3">
6788 <h4 id="intrusive_ref_counter_intrusive_ptr_add_ref">intrusive_ptr_add_ref</h4>
6789 <div class="listingblock">
6790 <div class="content">
6791 <pre class="highlight"><code>template&lt;class Derived, class CounterPolicy&gt;
6792   void intrusive_ptr_add_ref(
6793     const intrusive_ref_counter&lt;Derived, CounterPolicy&gt;* p) noexcept;</code></pre>
6794 </div>
6795 </div>
6796 <div class="ulist none">
6797 <ul class="none">
6798 <li>
6799 <p></p>
6800 <div class="dlist">
6801 <dl>
6802 <dt class="hdlist1">Effects</dt>
6803 <dd>
6804 <p>Increments the reference counter.</p>
6805 </dd>
6806 </dl>
6807 </div>
6808 </li>
6809 </ul>
6810 </div>
6811 </div>
6812 <div class="sect3">
6813 <h4 id="intrusive_ref_counter_intrusive_ptr_release">intrusive_ptr_release</h4>
6814 <div class="listingblock">
6815 <div class="content">
6816 <pre class="highlight"><code>template&lt;class Derived, class CounterPolicy&gt;
6817   void intrusive_ptr_release(
6818     const intrusive_ref_counter&lt;Derived, CounterPolicy&gt;* p) noexcept;</code></pre>
6819 </div>
6820 </div>
6821 <div class="ulist none">
6822 <ul class="none">
6823 <li>
6824 <p></p>
6825 <div class="dlist">
6826 <dl>
6827 <dt class="hdlist1">Effects</dt>
6828 <dd>
6829 <p>Decrements the reference counter. If the reference counter reaches
6830 0, calls <code>delete static_cast&lt;const Derived*&gt;(p)</code>.</p>
6831 </dd>
6832 </dl>
6833 </div>
6834 </li>
6835 </ul>
6836 </div>
6837 </div>
6838 </div>
6839 </div>
6840 </div>
6841 <div class="sect1">
6842 <h2 id="local_shared_ptr">local_shared_ptr: Shared Ownership within a Single Thread</h2>
6843 <div class="sectionbody">
6844 <div class="sect2">
6845 <h3 id="local_shared_ptr_description">Description</h3>
6846 <div class="paragraph">
6847 <p><code>local_shared_ptr</code> is nearly identical to <code>shared_ptr</code>, with the only difference of note being that its reference count is
6848 updated with non-atomic operations. As such, a <code>local_shared_ptr</code> and all its copies must reside in (be local to) a single
6849 thread (hence the name.)</p>
6850 </div>
6851 <div class="paragraph">
6852 <p><code>local_shared_ptr</code> can be converted to <code>shared_ptr</code> and vice versa. Creating a <code>local_shared_ptr</code> from a <code>shared_ptr</code> creates
6853 a new local reference count; this means that two <code>local_shared_ptr</code> instances, both created from the same <code>shared_ptr</code>, refer
6854 to the same object but don&#8217;t share the same count, and as such, can safely be used by two different threads.</p>
6855 </div>
6856 <div class="listingblock">
6857 <div class="title">Code Example 9. Two local_shared_ptr instances created from a shared_ptr</div>
6858 <div class="content">
6859 <pre class="highlight"><code>shared_ptr&lt;X&gt; p1( new X );
6860
6861 local_shared_ptr&lt;X&gt; p2( p1 ); // p2.local_use_count() == 1
6862 local_shared_ptr&lt;X&gt; p3( p1 ); // p3.local_use_count() also 1</code></pre>
6863 </div>
6864 </div>
6865 <div class="paragraph">
6866 <p>Creating the second <code>local_shared_ptr</code> from the first one, however, does lead to the two sharing the same count:</p>
6867 </div>
6868 <div class="listingblock">
6869 <div class="title">Code Example 10. A local_shared_ptr created from another local_shared_ptr</div>
6870 <div class="content">
6871 <pre class="highlight"><code>shared_ptr&lt;X&gt; p1( new X );
6872
6873 local_shared_ptr&lt;X&gt; p2( p1 ); // p2.local_use_count() == 1
6874 local_shared_ptr&lt;X&gt; p3( p2 ); // p3.local_use_count() == 2</code></pre>
6875 </div>
6876 </div>
6877 <div class="paragraph">
6878 <p>Two <code>shared_ptr</code> instances created from the same <code>local_shared_ptr</code> do share ownership:</p>
6879 </div>
6880 <div class="listingblock">
6881 <div class="title">Code Example 11. Two shared_ptr instances created from a local_shared_ptr</div>
6882 <div class="content">
6883 <pre class="highlight"><code>local_shared_ptr&lt;X&gt; p1( new X );
6884
6885 shared_ptr&lt;X&gt; p2( p1 ); // p2.use_count() == 2
6886 shared_ptr&lt;X&gt; p3( p1 ); // p3.use_count() == 3</code></pre>
6887 </div>
6888 </div>
6889 <div class="paragraph">
6890 <p>Here <code>p2.use_count()</code> is 2, because <code>p1</code> holds a reference, too.</p>
6891 </div>
6892 <div class="paragraph">
6893 <p>One can think of <code>local_shared_ptr&lt;T&gt;</code> as <code>shared_ptr&lt;shared_ptr&lt;T&gt;&gt;</code>, with the outer <code>shared_ptr</code> using non-atomic operations for
6894 its count. Converting from <code>local_shared_ptr</code> to <code>shared_ptr</code> gives you a copy of the inner <code>shared_ptr</code>; converting from <code>shared_ptr</code>
6895 wraps it into an outer <code>shared_ptr</code> with a non-atomic use count (conceptually speaking) and returns the result.</p>
6896 </div>
6897 </div>
6898 <div class="sect2">
6899 <h3 id="local_shared_ptr_synopsis">Synopsis</h3>
6900 <div class="paragraph">
6901 <p><code>local_shared_ptr</code> is defined in <code>&lt;boost/smart_ptr/local_shared_ptr.hpp&gt;</code>.</p>
6902 </div>
6903 <div class="listingblock">
6904 <div class="content">
6905 <pre class="highlight"><code>namespace boost {
6906
6907   template&lt;class T&gt; class local_shared_ptr {
6908   public:
6909
6910     typedef /*see below*/ element_type;
6911
6912     // constructors
6913
6914     constexpr local_shared_ptr() noexcept;
6915     constexpr local_shared_ptr(std::nullptr_t) noexcept;
6916
6917     template&lt;class Y&gt; explicit local_shared_ptr(Y * p);
6918
6919     template&lt;class Y, class D&gt; local_shared_ptr(Y * p, D d);
6920     template&lt;class D&gt; local_shared_ptr(std::nullptr_t p, D d);
6921
6922     template&lt;class Y, class D, class A&gt; local_shared_ptr(Y * p, D d, A a);
6923     template&lt;class D, class A&gt; local_shared_ptr(std::nullptr_t p, D d, A a);
6924
6925     local_shared_ptr(local_shared_ptr const &amp; r) noexcept;
6926     template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; const &amp; r) noexcept;
6927
6928     local_shared_ptr(local_shared_ptr &amp;&amp; r) noexcept;
6929     template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; &amp;&amp; r) noexcept;
6930
6931     template&lt;class Y&gt; local_shared_ptr( shared_ptr&lt;Y&gt; const &amp; r );
6932     template&lt;class Y&gt; local_shared_ptr( shared_ptr&lt;Y&gt; &amp;&amp; r );
6933
6934     template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;
6935     template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;
6936
6937     template&lt;class Y, class D&gt; local_shared_ptr(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);
6938
6939     // destructor
6940
6941     ~local_shared_ptr() noexcept;
6942
6943     // assignment
6944
6945     local_shared_ptr &amp; operator=(local_shared_ptr const &amp; r) noexcept;
6946     template&lt;class Y&gt; local_shared_ptr &amp; operator=(local_shared_ptr&lt;Y&gt; const &amp; r) noexcept;
6947
6948     local_shared_ptr &amp; operator=(local_shared_ptr const &amp;&amp; r) noexcept;
6949     template&lt;class Y&gt; local_shared_ptr &amp; operator=(local_shared_ptr&lt;Y&gt; const &amp;&amp; r) noexcept;
6950
6951     template&lt;class Y, class D&gt; local_shared_ptr &amp; operator=(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);
6952
6953     local_shared_ptr &amp; operator=(std::nullptr_t) noexcept;
6954
6955     // reset
6956
6957     void reset() noexcept;
6958
6959     template&lt;class Y&gt; void reset(Y * p);
6960     template&lt;class Y, class D&gt; void reset(Y * p, D d);
6961     template&lt;class Y, class D, class A&gt; void reset(Y * p, D d, A a);
6962
6963     template&lt;class Y&gt; void reset(local_shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;
6964     template&lt;class Y&gt; void reset(local_shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;
6965
6966     // accessors
6967
6968     T &amp; operator*() const noexcept; // only valid when T is not an array type
6969     T * operator-&gt;() const noexcept; // only valid when T is not an array type
6970
6971     // only valid when T is an array type
6972     element_type &amp; operator[](std::ptrdiff_t i) const noexcept;
6973
6974     element_type * get() const noexcept;
6975
6976     long local_use_count() const noexcept;
6977
6978     // conversions
6979
6980     explicit operator bool() const noexcept;
6981
6982     template&lt;class Y&gt; operator shared_ptr&lt;Y&gt;() const noexcept;
6983     template&lt;class Y&gt; operator weak_ptr&lt;Y&gt;() const noexcept;
6984
6985     // swap
6986
6987     void swap(local_shared_ptr &amp; b) noexcept;
6988
6989     // owner_before
6990
6991     template&lt;class Y&gt; bool owner_before(local_shared_ptr&lt;Y&gt; const &amp; rhs) const noexcept;
6992   };
6993
6994   // comparisons
6995
6996   template&lt;class T, class U&gt;
6997     bool operator==(local_shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;
6998   template&lt;class T, class U&gt;
6999     bool operator==(local_shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;
7000   template&lt;class T, class U&gt;
7001     bool operator==(shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;
7002
7003   template&lt;class T, class U&gt;
7004     bool operator!=(local_shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;
7005   template&lt;class T, class U&gt;
7006     bool operator!=(local_shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;
7007   template&lt;class T, class U&gt;
7008     bool operator!=(shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;
7009
7010   template&lt;class T&gt; bool operator==(local_shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;
7011   template&lt;class T&gt; bool operator==(std::nullptr_t, local_shared_ptr&lt;T&gt; const &amp; p) noexcept;
7012
7013   template&lt;class T&gt; bool operator!=(local_shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;
7014   template&lt;class T&gt; bool operator!=(std::nullptr_t, local_shared_ptr&lt;T&gt; const &amp; p) noexcept;
7015
7016   template&lt;class T, class U&gt;
7017     bool operator&lt;(local_shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;
7018
7019   // swap
7020
7021   template&lt;class T&gt; void swap(local_shared_ptr&lt;T&gt; &amp; a, local_shared_ptr&lt;T&gt; &amp; b) noexcept;
7022
7023   // get_pointer
7024
7025   template&lt;class T&gt;
7026     typename local_shared_ptr&lt;T&gt;::element_type *
7027       get_pointer(local_shared_ptr&lt;T&gt; const &amp; p) noexcept;
7028
7029   // casts
7030
7031   template&lt;class T, class U&gt;
7032     local_shared_ptr&lt;T&gt; static_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;
7033
7034   template&lt;class T, class U&gt;
7035     local_shared_ptr&lt;T&gt; const_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;
7036
7037   template&lt;class T, class U&gt;
7038     local_shared_ptr&lt;T&gt; dynamic_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;
7039
7040   template&lt;class T, class U&gt;
7041     local_shared_ptr&lt;T&gt; reinterpret_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;
7042
7043   // stream I/O
7044
7045   template&lt;class E, class T, class Y&gt;
7046     std::basic_ostream&lt;E, T&gt; &amp;
7047       operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, local_shared_ptr&lt;Y&gt; const &amp; p);
7048
7049   // get_deleter
7050
7051   template&lt;class D, class T&gt; D * get_deleter(local_shared_ptr&lt;T&gt; const &amp; p) noexcept;
7052 }</code></pre>
7053 </div>
7054 </div>
7055 </div>
7056 <div class="sect2">
7057 <h3 id="local_shared_ptr_members">Members</h3>
7058 <div class="sect3">
7059 <h4 id="local_shared_ptr_element_type">element_type</h4>
7060 <div class="listingblock">
7061 <div class="content">
7062 <pre class="highlight"><code>typedef ... element_type;</code></pre>
7063 </div>
7064 </div>
7065 <div class="paragraph">
7066 <p><code>element_type</code> is <code>T</code> when <code>T</code> is not an array type, and <code>U</code> when <code>T</code> is <code>U[]</code> or <code>U[N]</code>.</p>
7067 </div>
7068 </div>
7069 <div class="sect3">
7070 <h4 id="local_shared_ptr_default_constructor">default constructor</h4>
7071 <div class="listingblock">
7072 <div class="content">
7073 <pre class="highlight"><code>constexpr local_shared_ptr() noexcept;</code></pre>
7074 </div>
7075 </div>
7076 <div class="listingblock">
7077 <div class="content">
7078 <pre class="highlight"><code>constexpr local_shared_ptr(std::nullptr_t) noexcept;</code></pre>
7079 </div>
7080 </div>
7081 <div class="ulist none">
7082 <ul class="none">
7083 <li>
7084 <p></p>
7085 <div class="dlist">
7086 <dl>
7087 <dt class="hdlist1">Effects</dt>
7088 <dd>
7089 <p>Constructs an empty <code>local_shared_ptr</code>.</p>
7090 </dd>
7091 <dt class="hdlist1">Postconditions</dt>
7092 <dd>
7093 <p><code>local_use_count() == 0 &amp;&amp; get() == 0</code>.</p>
7094 </dd>
7095 </dl>
7096 </div>
7097 </li>
7098 </ul>
7099 </div>
7100 </div>
7101 <div class="sect3">
7102 <h4 id="local_shared_ptr_pointer_constructor">pointer constructor</h4>
7103 <div class="listingblock">
7104 <div class="content">
7105 <pre class="highlight"><code>template&lt;class Y&gt; explicit local_shared_ptr(Y * p);</code></pre>
7106 </div>
7107 </div>
7108 <div class="ulist none">
7109 <ul class="none">
7110 <li>
7111 <p></p>
7112 <div class="dlist">
7113 <dl>
7114 <dt class="hdlist1">Effects</dt>
7115 <dd>
7116 <p>Constructs a <code>local_shared_ptr</code> that owns <code>shared_ptr&lt;T&gt;( p )</code>.</p>
7117 </dd>
7118 <dt class="hdlist1">Postconditions</dt>
7119 <dd>
7120 <p><code>local_use_count() == 1 &amp;&amp; get() == p</code>.</p>
7121 </dd>
7122 <dt class="hdlist1">Throws</dt>
7123 <dd>
7124 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
7125 </dd>
7126 </dl>
7127 </div>
7128 </li>
7129 </ul>
7130 </div>
7131 </div>
7132 <div class="sect3">
7133 <h4 id="local_shared_ptr_constructors_taking_a_deleter">constructors taking a deleter</h4>
7134 <div class="listingblock">
7135 <div class="content">
7136 <pre class="highlight"><code>template&lt;class Y, class D&gt; local_shared_ptr(Y * p, D d);</code></pre>
7137 </div>
7138 </div>
7139 <div class="listingblock">
7140 <div class="content">
7141 <pre class="highlight"><code>template&lt;class D&gt; local_shared_ptr(std::nullptr_t p, D d);</code></pre>
7142 </div>
7143 </div>
7144 <div class="ulist none">
7145 <ul class="none">
7146 <li>
7147 <p></p>
7148 <div class="dlist">
7149 <dl>
7150 <dt class="hdlist1">Effects</dt>
7151 <dd>
7152 <p>Constructs a <code>local_shared_ptr</code> that owns <code>shared_ptr&lt;T&gt;( p, d )</code>.</p>
7153 </dd>
7154 <dt class="hdlist1">Postconditions</dt>
7155 <dd>
7156 <p><code>local_use_count() == 1 &amp;&amp; get() == p</code>.</p>
7157 </dd>
7158 <dt class="hdlist1">Throws</dt>
7159 <dd>
7160 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
7161 </dd>
7162 </dl>
7163 </div>
7164 </li>
7165 </ul>
7166 </div>
7167 <div class="listingblock">
7168 <div class="content">
7169 <pre class="highlight"><code>template&lt;class Y, class D, class A&gt; local_shared_ptr(Y * p, D d, A a);</code></pre>
7170 </div>
7171 </div>
7172 <div class="listingblock">
7173 <div class="content">
7174 <pre class="highlight"><code>template&lt;class D, class A&gt; local_shared_ptr(std::nullptr_t p, D d, A a);</code></pre>
7175 </div>
7176 </div>
7177 <div class="ulist none">
7178 <ul class="none">
7179 <li>
7180 <p></p>
7181 <div class="dlist">
7182 <dl>
7183 <dt class="hdlist1">Effects</dt>
7184 <dd>
7185 <p>Constructs a <code>local_shared_ptr</code> that owns <code>shared_ptr&lt;T&gt;( p, d, a )</code>.</p>
7186 </dd>
7187 <dt class="hdlist1">Postconditions</dt>
7188 <dd>
7189 <p><code>local_use_count() == 1 &amp;&amp; get() == p</code>.</p>
7190 </dd>
7191 <dt class="hdlist1">Throws</dt>
7192 <dd>
7193 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
7194 </dd>
7195 </dl>
7196 </div>
7197 </li>
7198 </ul>
7199 </div>
7200 </div>
7201 <div class="sect3">
7202 <h4 id="local_shared_ptr_copy_and_converting_constructors">copy and converting constructors</h4>
7203 <div class="listingblock">
7204 <div class="content">
7205 <pre class="highlight"><code>local_shared_ptr(local_shared_ptr const &amp; r) noexcept;</code></pre>
7206 </div>
7207 </div>
7208 <div class="listingblock">
7209 <div class="content">
7210 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
7211 </div>
7212 </div>
7213 <div class="ulist none">
7214 <ul class="none">
7215 <li>
7216 <p></p>
7217 <div class="dlist">
7218 <dl>
7219 <dt class="hdlist1">Requires</dt>
7220 <dd>
7221 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
7222 </dd>
7223 <dt class="hdlist1">Effects</dt>
7224 <dd>
7225 <p>If <code>r</code> is empty, constructs an empty <code>local_shared_ptr</code>; otherwise, constructs a <code>local_shared_ptr</code> that shares ownership with <code>r</code>.</p>
7226 </dd>
7227 <dt class="hdlist1">Postconditions</dt>
7228 <dd>
7229 <p><code>get() == r.get() &amp;&amp; local_use_count() == r.local_use_count()</code>.</p>
7230 </dd>
7231 </dl>
7232 </div>
7233 </li>
7234 </ul>
7235 </div>
7236 </div>
7237 <div class="sect3">
7238 <h4 id="local_shared_ptr_move_constructors">move constructors</h4>
7239 <div class="listingblock">
7240 <div class="content">
7241 <pre class="highlight"><code>local_shared_ptr(local_shared_ptr &amp;&amp; r) noexcept;</code></pre>
7242 </div>
7243 </div>
7244 <div class="listingblock">
7245 <div class="content">
7246 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; &amp;&amp; r) noexcept;</code></pre>
7247 </div>
7248 </div>
7249 <div class="ulist none">
7250 <ul class="none">
7251 <li>
7252 <p></p>
7253 <div class="dlist">
7254 <dl>
7255 <dt class="hdlist1">Requires</dt>
7256 <dd>
7257 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
7258 </dd>
7259 <dt class="hdlist1">Effects</dt>
7260 <dd>
7261 <p>Move-constructs a <code>local_shared_ptr</code> from <code>r</code>.</p>
7262 </dd>
7263 <dt class="hdlist1">Postconditions</dt>
7264 <dd>
7265 <p><code>*this</code> contains the old value of <code>r</code>. <code>r</code> is empty and <code>r.get() == 0</code>.</p>
7266 </dd>
7267 </dl>
7268 </div>
7269 </li>
7270 </ul>
7271 </div>
7272 </div>
7273 <div class="sect3">
7274 <h4 id="local_shared_ptr_shared_ptr_constructor">shared_ptr constructor</h4>
7275 <div class="listingblock">
7276 <div class="content">
7277 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr( shared_ptr&lt;Y&gt; const &amp; r );</code></pre>
7278 </div>
7279 </div>
7280 <div class="listingblock">
7281 <div class="content">
7282 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr( shared_ptr&lt;Y&gt; &amp;&amp; r );</code></pre>
7283 </div>
7284 </div>
7285 <div class="ulist none">
7286 <ul class="none">
7287 <li>
7288 <p></p>
7289 <div class="dlist">
7290 <dl>
7291 <dt class="hdlist1">Effects</dt>
7292 <dd>
7293 <p>Constructs a <code>local_shared_ptr</code> that owns <code>r</code>.</p>
7294 </dd>
7295 <dt class="hdlist1">Postconditions</dt>
7296 <dd>
7297 <p><code>local_use_count() == 1</code>. <code>get()</code> returns the old value of <code>r.get()</code>.</p>
7298 </dd>
7299 <dt class="hdlist1">Throws</dt>
7300 <dd>
7301 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
7302 </dd>
7303 </dl>
7304 </div>
7305 </li>
7306 </ul>
7307 </div>
7308 </div>
7309 <div class="sect3">
7310 <h4 id="local_shared_ptr_aliasing_constructor">aliasing constructor</h4>
7311 <div class="listingblock">
7312 <div class="content">
7313 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;</code></pre>
7314 </div>
7315 </div>
7316 <div class="ulist none">
7317 <ul class="none">
7318 <li>
7319 <p></p>
7320 <div class="dlist">
7321 <dl>
7322 <dt class="hdlist1">Effects</dt>
7323 <dd>
7324 <p>constructs a <code>local_shared_ptr</code> that shares ownership with <code>r</code> and stores <code>p</code>.</p>
7325 </dd>
7326 <dt class="hdlist1">Postconditions</dt>
7327 <dd>
7328 <p><code>get() == p &amp;&amp; local_use_count() == r.local_use_count()</code>.</p>
7329 </dd>
7330 </dl>
7331 </div>
7332 </li>
7333 </ul>
7334 </div>
7335 </div>
7336 <div class="sect3">
7337 <h4 id="local_shared_ptr_aliasing_move_constructor">aliasing move constructor</h4>
7338 <div class="listingblock">
7339 <div class="content">
7340 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr(local_shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;</code></pre>
7341 </div>
7342 </div>
7343 <div class="ulist none">
7344 <ul class="none">
7345 <li>
7346 <p></p>
7347 <div class="dlist">
7348 <dl>
7349 <dt class="hdlist1">Effects</dt>
7350 <dd>
7351 <p>Move-constructs a <code>local_shared_ptr</code> from <code>r</code>, while storing <code>p</code> instead.</p>
7352 </dd>
7353 <dt class="hdlist1">Postconditions</dt>
7354 <dd>
7355 <p><code>get() == p</code> and <code>local_use_count()</code> equals the old count of <code>r</code>. <code>r</code> is empty and <code>r.get() == 0</code>.</p>
7356 </dd>
7357 </dl>
7358 </div>
7359 </li>
7360 </ul>
7361 </div>
7362 </div>
7363 <div class="sect3">
7364 <h4 id="local_shared_ptr_unique_ptr_constructor">unique_ptr constructor</h4>
7365 <div class="listingblock">
7366 <div class="content">
7367 <pre class="highlight"><code>template&lt;class Y, class D&gt; local_shared_ptr(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);</code></pre>
7368 </div>
7369 </div>
7370 <div class="ulist none">
7371 <ul class="none">
7372 <li>
7373 <p></p>
7374 <div class="dlist">
7375 <dl>
7376 <dt class="hdlist1">Requires</dt>
7377 <dd>
7378 <p><code>Y*</code> should be convertible to <code>T*</code>.</p>
7379 </dd>
7380 <dt class="hdlist1">Effects</dt>
7381 <dd>
7382 <div class="ulist">
7383 <ul>
7384 <li>
7385 <p>When <code>r.get() == 0</code>, equivalent to <code>local_shared_ptr()</code>;</p>
7386 </li>
7387 <li>
7388 <p>Otherwise, constructs a <code>local_shared_ptr</code> that owns <code>shared_ptr&lt;T&gt;( std::move(r) )</code>.</p>
7389 </li>
7390 </ul>
7391 </div>
7392 </dd>
7393 <dt class="hdlist1">Throws</dt>
7394 <dd>
7395 <p><code>std::bad_alloc</code>, or an implementation-defined exception when a resource other than memory could not be obtained.</p>
7396 </dd>
7397 <dt class="hdlist1">Exception safety</dt>
7398 <dd>
7399 <p>If an exception is thrown, the constructor has no effect.</p>
7400 </dd>
7401 </dl>
7402 </div>
7403 </li>
7404 </ul>
7405 </div>
7406 </div>
7407 <div class="sect3">
7408 <h4 id="local_shared_ptr_destructor">destructor</h4>
7409 <div class="listingblock">
7410 <div class="content">
7411 <pre class="highlight"><code>~local_shared_ptr() noexcept;</code></pre>
7412 </div>
7413 </div>
7414 <div class="ulist none">
7415 <ul class="none">
7416 <li>
7417 <p></p>
7418 <div class="dlist">
7419 <dl>
7420 <dt class="hdlist1">Effects</dt>
7421 <dd>
7422 <div class="ulist">
7423 <ul>
7424 <li>
7425 <p>If <code>*this</code> is empty, or shares ownership with another <code>local_shared_ptr</code> instance (<code>local_use_count() &gt; 1</code>), there are no side effects.</p>
7426 </li>
7427 <li>
7428 <p>Otherwise, destroys the owned <code>shared_ptr</code>.</p>
7429 </li>
7430 </ul>
7431 </div>
7432 </dd>
7433 </dl>
7434 </div>
7435 </li>
7436 </ul>
7437 </div>
7438 </div>
7439 <div class="sect3">
7440 <h4 id="local_shared_ptr_assignment">assignment</h4>
7441 <div class="listingblock">
7442 <div class="content">
7443 <pre class="highlight"><code>local_shared_ptr &amp; operator=(local_shared_ptr const &amp; r) noexcept;</code></pre>
7444 </div>
7445 </div>
7446 <div class="listingblock">
7447 <div class="content">
7448 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr &amp; operator=(local_shared_ptr&lt;Y&gt; const &amp; r) noexcept;</code></pre>
7449 </div>
7450 </div>
7451 <div class="ulist none">
7452 <ul class="none">
7453 <li>
7454 <p></p>
7455 <div class="dlist">
7456 <dl>
7457 <dt class="hdlist1">Effects</dt>
7458 <dd>
7459 <p>Equivalent to <code>local_shared_ptr(r).swap(*this)</code>.</p>
7460 </dd>
7461 <dt class="hdlist1">Returns</dt>
7462 <dd>
7463 <p><code>*this</code>.</p>
7464 </dd>
7465 </dl>
7466 </div>
7467 </li>
7468 </ul>
7469 </div>
7470 <div class="listingblock">
7471 <div class="content">
7472 <pre class="highlight"><code>local_shared_ptr &amp; operator=(local_shared_ptr &amp;&amp; r) noexcept;</code></pre>
7473 </div>
7474 </div>
7475 <div class="listingblock">
7476 <div class="content">
7477 <pre class="highlight"><code>template&lt;class Y&gt; local_shared_ptr &amp; operator=(local_shared_ptr&lt;Y&gt; &amp;&amp; r) noexcept;</code></pre>
7478 </div>
7479 </div>
7480 <div class="listingblock">
7481 <div class="content">
7482 <pre class="highlight"><code>template&lt;class Y, class D&gt; local_shared_ptr &amp; operator=(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);</code></pre>
7483 </div>
7484 </div>
7485 <div class="ulist none">
7486 <ul class="none">
7487 <li>
7488 <p></p>
7489 <div class="dlist">
7490 <dl>
7491 <dt class="hdlist1">Effects</dt>
7492 <dd>
7493 <p>Equivalent to <code>local_shared_ptr(std::move(r)).swap(*this)</code>.</p>
7494 </dd>
7495 <dt class="hdlist1">Returns</dt>
7496 <dd>
7497 <p><code>*this</code>.</p>
7498 </dd>
7499 </dl>
7500 </div>
7501 </li>
7502 </ul>
7503 </div>
7504 <div class="listingblock">
7505 <div class="content">
7506 <pre class="highlight"><code>local_shared_ptr &amp; operator=(std::nullptr_t) noexcept;</code></pre>
7507 </div>
7508 </div>
7509 <div class="ulist none">
7510 <ul class="none">
7511 <li>
7512 <p></p>
7513 <div class="dlist">
7514 <dl>
7515 <dt class="hdlist1">Effects</dt>
7516 <dd>
7517 <p>Equivalent to <code>local_shared_ptr().swap(*this)</code>.</p>
7518 </dd>
7519 <dt class="hdlist1">Returns</dt>
7520 <dd>
7521 <p><code>*this</code>.</p>
7522 </dd>
7523 </dl>
7524 </div>
7525 </li>
7526 </ul>
7527 </div>
7528 </div>
7529 <div class="sect3">
7530 <h4 id="local_shared_ptr_reset">reset</h4>
7531 <div class="listingblock">
7532 <div class="content">
7533 <pre class="highlight"><code>void reset() noexcept;</code></pre>
7534 </div>
7535 </div>
7536 <div class="ulist none">
7537 <ul class="none">
7538 <li>
7539 <p></p>
7540 <div class="dlist">
7541 <dl>
7542 <dt class="hdlist1">Effects</dt>
7543 <dd>
7544 <p>Equivalent to <code>local_shared_ptr().swap(*this)</code>.</p>
7545 </dd>
7546 </dl>
7547 </div>
7548 </li>
7549 </ul>
7550 </div>
7551 <div class="listingblock">
7552 <div class="content">
7553 <pre class="highlight"><code>template&lt;class Y&gt; void reset(Y * p);</code></pre>
7554 </div>
7555 </div>
7556 <div class="ulist none">
7557 <ul class="none">
7558 <li>
7559 <p></p>
7560 <div class="dlist">
7561 <dl>
7562 <dt class="hdlist1">Effects</dt>
7563 <dd>
7564 <p>Equivalent to <code>local_shared_ptr(p).swap(*this)</code>.</p>
7565 </dd>
7566 </dl>
7567 </div>
7568 </li>
7569 </ul>
7570 </div>
7571 <div class="listingblock">
7572 <div class="content">
7573 <pre class="highlight"><code>template&lt;class Y, class D&gt; void reset(Y * p, D d);</code></pre>
7574 </div>
7575 </div>
7576 <div class="ulist none">
7577 <ul class="none">
7578 <li>
7579 <p></p>
7580 <div class="dlist">
7581 <dl>
7582 <dt class="hdlist1">Effects</dt>
7583 <dd>
7584 <p>Equivalent to <code>local_shared_ptr(p, d).swap(*this)</code>.</p>
7585 </dd>
7586 </dl>
7587 </div>
7588 </li>
7589 </ul>
7590 </div>
7591 <div class="listingblock">
7592 <div class="content">
7593 <pre class="highlight"><code>template&lt;class Y, class D, class A&gt; void reset(Y * p, D d, A a);</code></pre>
7594 </div>
7595 </div>
7596 <div class="ulist none">
7597 <ul class="none">
7598 <li>
7599 <p></p>
7600 <div class="dlist">
7601 <dl>
7602 <dt class="hdlist1">Effects</dt>
7603 <dd>
7604 <p>Equivalent to <code>local_shared_ptr(p, d, a).swap(*this)</code>.</p>
7605 </dd>
7606 </dl>
7607 </div>
7608 </li>
7609 </ul>
7610 </div>
7611 <div class="listingblock">
7612 <div class="content">
7613 <pre class="highlight"><code>template&lt;class Y&gt; void reset(local_shared_ptr&lt;Y&gt; const &amp; r, element_type * p) noexcept;</code></pre>
7614 </div>
7615 </div>
7616 <div class="ulist none">
7617 <ul class="none">
7618 <li>
7619 <p></p>
7620 <div class="dlist">
7621 <dl>
7622 <dt class="hdlist1">Effects</dt>
7623 <dd>
7624 <p>Equivalent to <code>local_shared_ptr(r, p).swap(*this)</code>.</p>
7625 </dd>
7626 </dl>
7627 </div>
7628 </li>
7629 </ul>
7630 </div>
7631 <div class="listingblock">
7632 <div class="content">
7633 <pre class="highlight"><code>template&lt;class Y&gt; void reset(local_shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p) noexcept;</code></pre>
7634 </div>
7635 </div>
7636 <div class="ulist none">
7637 <ul class="none">
7638 <li>
7639 <p></p>
7640 <div class="dlist">
7641 <dl>
7642 <dt class="hdlist1">Effects</dt>
7643 <dd>
7644 <p>Equivalent to <code>local_shared_ptr(std::move(r), p).swap(*this)</code>.</p>
7645 </dd>
7646 </dl>
7647 </div>
7648 </li>
7649 </ul>
7650 </div>
7651 </div>
7652 <div class="sect3">
7653 <h4 id="local_shared_ptr_indirection">indirection</h4>
7654 <div class="listingblock">
7655 <div class="content">
7656 <pre class="highlight"><code>T &amp; operator*() const noexcept;</code></pre>
7657 </div>
7658 </div>
7659 <div class="ulist none">
7660 <ul class="none">
7661 <li>
7662 <p></p>
7663 <div class="dlist">
7664 <dl>
7665 <dt class="hdlist1">Requires</dt>
7666 <dd>
7667 <p><code>T</code> should not be an array type.</p>
7668 </dd>
7669 <dt class="hdlist1">Returns</dt>
7670 <dd>
7671 <p><code>*get()</code>.</p>
7672 </dd>
7673 </dl>
7674 </div>
7675 </li>
7676 </ul>
7677 </div>
7678 <div class="listingblock">
7679 <div class="content">
7680 <pre class="highlight"><code>T * operator-&gt;() const noexcept;</code></pre>
7681 </div>
7682 </div>
7683 <div class="ulist none">
7684 <ul class="none">
7685 <li>
7686 <p></p>
7687 <div class="dlist">
7688 <dl>
7689 <dt class="hdlist1">Requires</dt>
7690 <dd>
7691 <p><code>T</code> should not be an array type.</p>
7692 </dd>
7693 <dt class="hdlist1">Returns</dt>
7694 <dd>
7695 <p><code>get()</code>.</p>
7696 </dd>
7697 </dl>
7698 </div>
7699 </li>
7700 </ul>
7701 </div>
7702 <div class="listingblock">
7703 <div class="content">
7704 <pre class="highlight"><code>element_type &amp; operator[](std::ptrdiff_t i) const noexcept;</code></pre>
7705 </div>
7706 </div>
7707 <div class="ulist none">
7708 <ul class="none">
7709 <li>
7710 <p></p>
7711 <div class="dlist">
7712 <dl>
7713 <dt class="hdlist1">Requires</dt>
7714 <dd>
7715 <p><code>T</code> should be an array type. The stored pointer must not be 0. <code>i &gt;= 0</code>. If <code>T</code> is <code>U[N]</code>, <code>i &lt; N</code>.</p>
7716 </dd>
7717 <dt class="hdlist1">Returns</dt>
7718 <dd>
7719 <p><code>get()[i]</code>.</p>
7720 </dd>
7721 </dl>
7722 </div>
7723 </li>
7724 </ul>
7725 </div>
7726 </div>
7727 <div class="sect3">
7728 <h4 id="local_shared_ptr_get">get</h4>
7729 <div class="listingblock">
7730 <div class="content">
7731 <pre class="highlight"><code>element_type * get() const noexcept;</code></pre>
7732 </div>
7733 </div>
7734 <div class="ulist none">
7735 <ul class="none">
7736 <li>
7737 <p></p>
7738 <div class="dlist">
7739 <dl>
7740 <dt class="hdlist1">Returns</dt>
7741 <dd>
7742 <p>The stored pointer.</p>
7743 </dd>
7744 </dl>
7745 </div>
7746 </li>
7747 </ul>
7748 </div>
7749 </div>
7750 <div class="sect3">
7751 <h4 id="local_shared_ptr_local_use_count">local_use_count</h4>
7752 <div class="listingblock">
7753 <div class="content">
7754 <pre class="highlight"><code>long local_use_count() const noexcept;</code></pre>
7755 </div>
7756 </div>
7757 <div class="ulist none">
7758 <ul class="none">
7759 <li>
7760 <p></p>
7761 <div class="dlist">
7762 <dl>
7763 <dt class="hdlist1">Returns</dt>
7764 <dd>
7765 <p>The number of <code>local_shared_ptr</code> objects, <code>*this</code> included, that share ownership with <code>*this</code>, or 0 when <code>*this</code> is empty.</p>
7766 </dd>
7767 </dl>
7768 </div>
7769 </li>
7770 </ul>
7771 </div>
7772 </div>
7773 <div class="sect3">
7774 <h4 id="local_shared_ptr_conversions">conversions</h4>
7775 <div class="listingblock">
7776 <div class="content">
7777 <pre class="highlight"><code>explicit operator bool() const noexcept;</code></pre>
7778 </div>
7779 </div>
7780 <div class="ulist none">
7781 <ul class="none">
7782 <li>
7783 <p></p>
7784 <div class="dlist">
7785 <dl>
7786 <dt class="hdlist1">Returns</dt>
7787 <dd>
7788 <p><code>get() != 0</code>.</p>
7789 </dd>
7790 </dl>
7791 </div>
7792 </li>
7793 </ul>
7794 </div>
7795 <div class="admonitionblock note">
7796 <table>
7797 <tr>
7798 <td class="icon">
7799 <div class="title">Note</div>
7800 </td>
7801 <td class="content">
7802 On C++03 compilers, the return value is of an unspecified type.
7803 </td>
7804 </tr>
7805 </table>
7806 </div>
7807 <div class="listingblock">
7808 <div class="content">
7809 <pre class="highlight"><code>template&lt;class Y&gt; operator shared_ptr&lt;Y&gt;() const noexcept;</code></pre>
7810 </div>
7811 </div>
7812 <div class="listingblock">
7813 <div class="content">
7814 <pre class="highlight"><code>template&lt;class Y&gt; operator weak_ptr&lt;Y&gt;() const noexcept;</code></pre>
7815 </div>
7816 </div>
7817 <div class="ulist none">
7818 <ul class="none">
7819 <li>
7820 <p></p>
7821 <div class="dlist">
7822 <dl>
7823 <dt class="hdlist1">Requires</dt>
7824 <dd>
7825 <p><code>T*</code> should be convertible to <code>Y*</code>.</p>
7826 </dd>
7827 <dt class="hdlist1">Returns</dt>
7828 <dd>
7829 <p>a copy of the owned <code>shared_ptr</code>.</p>
7830 </dd>
7831 </dl>
7832 </div>
7833 </li>
7834 </ul>
7835 </div>
7836 </div>
7837 <div class="sect3">
7838 <h4 id="local_shared_ptr_swap">swap</h4>
7839 <div class="listingblock">
7840 <div class="content">
7841 <pre class="highlight"><code>void swap(local_shared_ptr &amp; b) noexcept;</code></pre>
7842 </div>
7843 </div>
7844 <div class="ulist none">
7845 <ul class="none">
7846 <li>
7847 <p></p>
7848 <div class="dlist">
7849 <dl>
7850 <dt class="hdlist1">Effects</dt>
7851 <dd>
7852 <p>Exchanges the contents of the two smart pointers.</p>
7853 </dd>
7854 </dl>
7855 </div>
7856 </li>
7857 </ul>
7858 </div>
7859 </div>
7860 <div class="sect3">
7861 <h4 id="local_shared_ptr_owner_before">owner_before</h4>
7862 <div class="listingblock">
7863 <div class="content">
7864 <pre class="highlight"><code>template&lt;class Y&gt; bool owner_before(local_shared_ptr&lt;Y&gt; const &amp; rhs) const noexcept;</code></pre>
7865 </div>
7866 </div>
7867 <div class="ulist none">
7868 <ul class="none">
7869 <li>
7870 <p></p>
7871 <div class="dlist">
7872 <dl>
7873 <dt class="hdlist1">Effects</dt>
7874 <dd>
7875 <p>See the description of <code>operator&lt;</code>.</p>
7876 </dd>
7877 </dl>
7878 </div>
7879 </li>
7880 </ul>
7881 </div>
7882 </div>
7883 </div>
7884 <div class="sect2">
7885 <h3 id="local_shared_ptr_free_functions">Free Functions</h3>
7886 <div class="sect3">
7887 <h4 id="local_shared_ptr_comparison">comparison</h4>
7888 <div class="listingblock">
7889 <div class="content">
7890 <pre class="highlight"><code>template&lt;class T, class U&gt;
7891   bool operator==(local_shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
7892 </div>
7893 </div>
7894 <div class="listingblock">
7895 <div class="content">
7896 <pre class="highlight"><code>template&lt;class T, class U&gt;
7897   bool operator==(local_shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
7898 </div>
7899 </div>
7900 <div class="listingblock">
7901 <div class="content">
7902 <pre class="highlight"><code>template&lt;class T, class U&gt;
7903   bool operator==(shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
7904 </div>
7905 </div>
7906 <div class="ulist none">
7907 <ul class="none">
7908 <li>
7909 <p></p>
7910 <div class="dlist">
7911 <dl>
7912 <dt class="hdlist1">Returns</dt>
7913 <dd>
7914 <p><code>a.get() == b.get()</code>.</p>
7915 </dd>
7916 </dl>
7917 </div>
7918 </li>
7919 </ul>
7920 </div>
7921 <div class="listingblock">
7922 <div class="content">
7923 <pre class="highlight"><code>template&lt;class T, class U&gt;
7924   bool operator!=(local_shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
7925 </div>
7926 </div>
7927 <div class="listingblock">
7928 <div class="content">
7929 <pre class="highlight"><code>template&lt;class T, class U&gt;
7930   bool operator!=(local_shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
7931 </div>
7932 </div>
7933 <div class="listingblock">
7934 <div class="content">
7935 <pre class="highlight"><code>template&lt;class T, class U&gt;
7936   bool operator!=(shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
7937 </div>
7938 </div>
7939 <div class="ulist none">
7940 <ul class="none">
7941 <li>
7942 <p></p>
7943 <div class="dlist">
7944 <dl>
7945 <dt class="hdlist1">Returns</dt>
7946 <dd>
7947 <p><code>a.get() != b.get()</code>.</p>
7948 </dd>
7949 </dl>
7950 </div>
7951 </li>
7952 </ul>
7953 </div>
7954 <div class="listingblock">
7955 <div class="content">
7956 <pre class="highlight"><code>template&lt;class T&gt; bool operator==(local_shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;</code></pre>
7957 </div>
7958 </div>
7959 <div class="listingblock">
7960 <div class="content">
7961 <pre class="highlight"><code>template&lt;class T&gt; bool operator==(std::nullptr_t, local_shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
7962 </div>
7963 </div>
7964 <div class="ulist none">
7965 <ul class="none">
7966 <li>
7967 <p></p>
7968 <div class="dlist">
7969 <dl>
7970 <dt class="hdlist1">Returns</dt>
7971 <dd>
7972 <p><code>p.get() == 0</code>.</p>
7973 </dd>
7974 </dl>
7975 </div>
7976 </li>
7977 </ul>
7978 </div>
7979 <div class="listingblock">
7980 <div class="content">
7981 <pre class="highlight"><code>template&lt;class T&gt; bool operator!=(local_shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t) noexcept;</code></pre>
7982 </div>
7983 </div>
7984 <div class="listingblock">
7985 <div class="content">
7986 <pre class="highlight"><code>template&lt;class T&gt; bool operator!=(std::nullptr_t, local_shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
7987 </div>
7988 </div>
7989 <div class="ulist none">
7990 <ul class="none">
7991 <li>
7992 <p></p>
7993 <div class="dlist">
7994 <dl>
7995 <dt class="hdlist1">Returns</dt>
7996 <dd>
7997 <p><code>p.get() != 0</code>.</p>
7998 </dd>
7999 </dl>
8000 </div>
8001 </li>
8002 </ul>
8003 </div>
8004 <div class="listingblock">
8005 <div class="content">
8006 <pre class="highlight"><code>template&lt;class T, class U&gt;
8007   bool operator&lt;(local_shared_ptr&lt;T&gt; const &amp; a, local_shared_ptr&lt;U&gt; const &amp; b) noexcept;</code></pre>
8008 </div>
8009 </div>
8010 <div class="ulist none">
8011 <ul class="none">
8012 <li>
8013 <p></p>
8014 <div class="dlist">
8015 <dl>
8016 <dt class="hdlist1">Returns</dt>
8017 <dd>
8018 <p>An unspecified value such that</p>
8019 <div class="ulist">
8020 <ul>
8021 <li>
8022 <p><code>operator&lt;</code> is a strict weak ordering as described in section [lib.alg.sorting] of the C&#43;&#43; standard;</p>
8023 </li>
8024 <li>
8025 <p>under the equivalence relation defined by <code>operator&lt;</code>, <code>!(a &lt; b) &amp;&amp; !(b &lt; a)</code>, two <code>local_shared_ptr</code> instances
8026 are equivalent if and only if they share ownership or are both empty.</p>
8027 </li>
8028 </ul>
8029 </div>
8030 </dd>
8031 </dl>
8032 </div>
8033 </li>
8034 </ul>
8035 </div>
8036 <div class="admonitionblock note">
8037 <table>
8038 <tr>
8039 <td class="icon">
8040 <div class="title">Note</div>
8041 </td>
8042 <td class="content">
8043 Allows <code>local_shared_ptr</code> objects to be used as keys in associative containers.
8044 </td>
8045 </tr>
8046 </table>
8047 </div>
8048 <div class="admonitionblock note">
8049 <table>
8050 <tr>
8051 <td class="icon">
8052 <div class="title">Note</div>
8053 </td>
8054 <td class="content">
8055 The rest of the comparison operators are omitted by design.
8056 </td>
8057 </tr>
8058 </table>
8059 </div>
8060 </div>
8061 <div class="sect3">
8062 <h4 id="local_shared_ptr_swap_2">swap</h4>
8063 <div class="listingblock">
8064 <div class="content">
8065 <pre class="highlight"><code>template&lt;class T&gt; void swap(local_shared_ptr&lt;T&gt; &amp; a, local_shared_ptr&lt;T&gt; &amp; b) noexcept;</code></pre>
8066 </div>
8067 </div>
8068 <div class="ulist none">
8069 <ul class="none">
8070 <li>
8071 <p></p>
8072 <div class="dlist">
8073 <dl>
8074 <dt class="hdlist1">Effects</dt>
8075 <dd>
8076 <p>Equivalent to <code>a.swap(b)</code>.</p>
8077 </dd>
8078 </dl>
8079 </div>
8080 </li>
8081 </ul>
8082 </div>
8083 </div>
8084 <div class="sect3">
8085 <h4 id="local_shared_ptr_get_pointer">get_pointer</h4>
8086 <div class="listingblock">
8087 <div class="content">
8088 <pre class="highlight"><code>template&lt;class T&gt;
8089   typename local_shared_ptr&lt;T&gt;::element_type *
8090     get_pointer(local_shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
8091 </div>
8092 </div>
8093 <div class="ulist none">
8094 <ul class="none">
8095 <li>
8096 <p></p>
8097 <div class="dlist">
8098 <dl>
8099 <dt class="hdlist1">Returns</dt>
8100 <dd>
8101 <p><code>p.get()</code>.</p>
8102 </dd>
8103 </dl>
8104 </div>
8105 </li>
8106 </ul>
8107 </div>
8108 <div class="admonitionblock note">
8109 <table>
8110 <tr>
8111 <td class="icon">
8112 <div class="title">Note</div>
8113 </td>
8114 <td class="content">
8115 Provided as an aid to generic programming. Used by <code>mem_fn</code>.
8116 </td>
8117 </tr>
8118 </table>
8119 </div>
8120 </div>
8121 <div class="sect3">
8122 <h4 id="local_shared_ptr_static_pointer_cast">static_pointer_cast</h4>
8123 <div class="listingblock">
8124 <div class="content">
8125 <pre class="highlight"><code>template&lt;class T, class U&gt;
8126   local_shared_ptr&lt;T&gt; static_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
8127 </div>
8128 </div>
8129 <div class="ulist none">
8130 <ul class="none">
8131 <li>
8132 <p></p>
8133 <div class="dlist">
8134 <dl>
8135 <dt class="hdlist1">Requires</dt>
8136 <dd>
8137 <p>The expression <code>static_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
8138 </dd>
8139 <dt class="hdlist1">Returns</dt>
8140 <dd>
8141 <p><code>local_shared_ptr&lt;T&gt;( r, static_cast&lt;typename local_shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
8142 </dd>
8143 </dl>
8144 </div>
8145 </li>
8146 </ul>
8147 </div>
8148 <div class="admonitionblock caution">
8149 <table>
8150 <tr>
8151 <td class="icon">
8152 <div class="title">Caution</div>
8153 </td>
8154 <td class="content">
8155 The seemingly equivalent expression <code>local_shared_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code> will eventually
8156 result in undefined behavior, attempting to delete the same object twice.
8157 </td>
8158 </tr>
8159 </table>
8160 </div>
8161 </div>
8162 <div class="sect3">
8163 <h4 id="local_shared_ptr_const_pointer_cast">const_pointer_cast</h4>
8164 <div class="listingblock">
8165 <div class="content">
8166 <pre class="highlight"><code>template&lt;class T, class U&gt;
8167   local_shared_ptr&lt;T&gt; const_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
8168 </div>
8169 </div>
8170 <div class="ulist none">
8171 <ul class="none">
8172 <li>
8173 <p></p>
8174 <div class="dlist">
8175 <dl>
8176 <dt class="hdlist1">Requires</dt>
8177 <dd>
8178 <p>The expression <code>const_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
8179 </dd>
8180 <dt class="hdlist1">Returns</dt>
8181 <dd>
8182 <p><code>local_shared_ptr&lt;T&gt;( r, const_cast&lt;typename local_shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
8183 </dd>
8184 </dl>
8185 </div>
8186 </li>
8187 </ul>
8188 </div>
8189 </div>
8190 <div class="sect3">
8191 <h4 id="local_shared_ptr_dynamic_pointer_cast">dynamic_pointer_cast</h4>
8192 <div class="listingblock">
8193 <div class="content">
8194 <pre class="highlight"><code>template&lt;class T, class U&gt;
8195     local_shared_ptr&lt;T&gt; dynamic_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
8196 </div>
8197 </div>
8198 <div class="ulist none">
8199 <ul class="none">
8200 <li>
8201 <p></p>
8202 <div class="dlist">
8203 <dl>
8204 <dt class="hdlist1">Requires</dt>
8205 <dd>
8206 <p>The expression <code>dynamic_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
8207 </dd>
8208 <dt class="hdlist1">Returns</dt>
8209 <dd>
8210 <div class="ulist">
8211 <ul>
8212 <li>
8213 <p>When <code>dynamic_cast&lt;typename local_shared_ptr&lt;T&gt;::element_type*&gt;(r.get())</code> returns a nonzero value <code>p</code>, <code>local_shared_ptr&lt;T&gt;(r, p)</code>;</p>
8214 </li>
8215 <li>
8216 <p>Otherwise, <code>local_shared_ptr&lt;T&gt;()</code>.</p>
8217 </li>
8218 </ul>
8219 </div>
8220 </dd>
8221 </dl>
8222 </div>
8223 </li>
8224 </ul>
8225 </div>
8226 </div>
8227 <div class="sect3">
8228 <h4 id="local_shared_ptr_reinterpret_pointer_cast">reinterpret_pointer_cast</h4>
8229 <div class="listingblock">
8230 <div class="content">
8231 <pre class="highlight"><code>template&lt;class T, class U&gt;
8232   local_shared_ptr&lt;T&gt; reinterpret_pointer_cast(local_shared_ptr&lt;U&gt; const &amp; r) noexcept;</code></pre>
8233 </div>
8234 </div>
8235 <div class="ulist none">
8236 <ul class="none">
8237 <li>
8238 <p></p>
8239 <div class="dlist">
8240 <dl>
8241 <dt class="hdlist1">Requires</dt>
8242 <dd>
8243 <p>The expression <code>reinterpret_cast&lt;T*&gt;( (U*)0 )</code> must be well-formed.</p>
8244 </dd>
8245 <dt class="hdlist1">Returns</dt>
8246 <dd>
8247 <p><code>local_shared_ptr&lt;T&gt;( r, reinterpret_cast&lt;typename local_shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
8248 </dd>
8249 </dl>
8250 </div>
8251 </li>
8252 </ul>
8253 </div>
8254 </div>
8255 <div class="sect3">
8256 <h4 id="local_shared_ptr_operator">operator&lt;&lt;</h4>
8257 <div class="listingblock">
8258 <div class="content">
8259 <pre class="highlight"><code>template&lt;class E, class T, class Y&gt;
8260   std::basic_ostream&lt;E, T&gt; &amp;
8261     operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, local_shared_ptr&lt;Y&gt; const &amp; p);</code></pre>
8262 </div>
8263 </div>
8264 <div class="ulist none">
8265 <ul class="none">
8266 <li>
8267 <p></p>
8268 <div class="dlist">
8269 <dl>
8270 <dt class="hdlist1">Effects</dt>
8271 <dd>
8272 <p><code>os &lt;&lt; p.get();</code>.</p>
8273 </dd>
8274 <dt class="hdlist1">Returns</dt>
8275 <dd>
8276 <p><code>os</code>.</p>
8277 </dd>
8278 </dl>
8279 </div>
8280 </li>
8281 </ul>
8282 </div>
8283 </div>
8284 <div class="sect3">
8285 <h4 id="local_shared_ptr_get_deleter">get_deleter</h4>
8286 <div class="listingblock">
8287 <div class="content">
8288 <pre class="highlight"><code>template&lt;class D, class T&gt;
8289   D * get_deleter(local_shared_ptr&lt;T&gt; const &amp; p) noexcept;</code></pre>
8290 </div>
8291 </div>
8292 <div class="ulist none">
8293 <ul class="none">
8294 <li>
8295 <p></p>
8296 <div class="dlist">
8297 <dl>
8298 <dt class="hdlist1">Returns</dt>
8299 <dd>
8300 <p>If <code>*this</code> owns a <code>shared_ptr</code> instance <code>p</code>, <code>get_deleter&lt;D&gt;( p )</code>, otherwise 0.</p>
8301 </dd>
8302 </dl>
8303 </div>
8304 </li>
8305 </ul>
8306 </div>
8307 </div>
8308 </div>
8309 </div>
8310 </div>
8311 <div class="sect1">
8312 <h2 id="make_local_shared">make_local_shared: Creating local_shared_ptr</h2>
8313 <div class="sectionbody">
8314 <div class="sect2">
8315 <h3 id="make_local_shared_description">Description</h3>
8316 <div class="paragraph">
8317 <p>The function templates <code>make_local_shared</code> and <code>allocate_local_shared</code> provide
8318 convenient, safe and efficient ways to create <code>local_shared_ptr</code> objects. They
8319 are analogous to <code>make_shared</code> and <code>allocate_shared</code> for <code>shared_ptr</code>.</p>
8320 </div>
8321 </div>
8322 <div class="sect2">
8323 <h3 id="make_local_shared_synopsis">Synopsis</h3>
8324 <div class="paragraph">
8325 <p><code>make_local_shared</code> and <code>allocate_local_shared</code> are defined in
8326 <code>&lt;boost/smart_ptr/make_local_shared.hpp&gt;</code>.</p>
8327 </div>
8328 <div class="listingblock">
8329 <div class="content">
8330 <pre class="highlight"><code>namespace boost {
8331   <code>// T is not an array</code>
8332   template&lt;class T, class... Args&gt;
8333     local_shared_ptr&lt;T&gt; make_local_shared(Args&amp;&amp;... args);
8334   template&lt;class T, class A, class... Args&gt;
8335     local_shared_ptr&lt;T&gt; allocate_local_shared(const A&amp; a, Args&amp;&amp;... args);
8336
8337   <code>// T is an array of unknown bounds</code>
8338   template&lt;class T&gt;
8339     local_shared_ptr&lt;T&gt; make_local_shared(std::size_t n);
8340   template&lt;class T, class A&gt;
8341     local_shared_ptr&lt;T&gt; allocate_local_shared(const A&amp; a, std::size_t n);
8342
8343   <code>// T is an array of known bounds</code>
8344   template&lt;class T&gt;
8345     local_shared_ptr&lt;T&gt; make_local_shared();
8346   template&lt;class T, class A&gt;
8347     local_shared_ptr&lt;T&gt; allocate_local_shared(const A&amp; a);
8348
8349   <code>// T is an array of unknown bounds</code>
8350   template&lt;class T&gt;
8351     local_shared_ptr&lt;T&gt; make_local_shared(std::size_t n,
8352       const remove_extent_t&lt;T&gt;&amp; v);
8353   template&lt;class T, class A&gt;
8354     local_shared_ptr&lt;T&gt; allocate_local_shared(const A&amp; a, std::size_t n,
8355       const remove_extent_t&lt;T&gt;&amp; v);
8356
8357   <code>// T is an array of known bounds</code>
8358   template&lt;class T&gt;
8359     local_shared_ptr&lt;T&gt; make_local_shared(const remove_extent_t&lt;T&gt;&amp; v);
8360   template&lt;class T, class A&gt;
8361     local_shared_ptr&lt;T&gt; allocate_local_shared(const A&amp; a,
8362       const remove_extent_t&lt;T&gt;&amp; v);
8363
8364   <code>// T is not an array of known bounds</code>
8365   template&lt;class T&gt;
8366     local_shared_ptr&lt;T&gt; make_local_shared_noinit();
8367   template&lt;class T, class A&gt;
8368     local_shared_ptr&lt;T&gt; allocate_local_shared_noinit(const A&amp; a);
8369
8370   <code>// T is an array of unknown bounds</code>
8371   template&lt;class T&gt;
8372     local_shared_ptr&lt;T&gt; make_local_shared_noinit(std::size_t n);
8373   template&lt;class T, class A&gt;
8374     local_shared_ptr&lt;T&gt; allocate_local_shared_noinit(const A&amp; a,
8375       std::size_t n);
8376 }</code></pre>
8377 </div>
8378 </div>
8379 </div>
8380 <div class="sect2">
8381 <h3 id="make_local_shared_description_2">Description</h3>
8382 <div class="paragraph">
8383 <p>The requirements and effects of these functions are the same as <code>make_shared</code>
8384 and <code>allocate_shared</code>, except that a <code>local_shared_ptr</code> is returned.</p>
8385 </div>
8386 </div>
8387 </div>
8388 </div>
8389 <div class="sect1">
8390 <h2 id="pointer_cast">Generic Pointer Casts</h2>
8391 <div class="sectionbody">
8392 <div class="sect2">
8393 <h3 id="pointer_cast_description">Description</h3>
8394 <div class="paragraph">
8395 <p>The pointer cast function templates (<code>static_pointer_cast</code>,
8396 <code>dynamic_pointer_cast</code>, <code>const_pointer_cast</code>, and <code>reinterpret_pointer_cast</code>)
8397 provide a way to write generic pointer castings for raw pointers,
8398 <code>std::shared_ptr</code> and <code>std::unique_ptr</code>.</p>
8399 </div>
8400 <div class="paragraph">
8401 <p>There is test and example code in
8402 <a href="../../test/pointer_cast_test.cpp">pointer_cast_test.cpp</a></p>
8403 </div>
8404 </div>
8405 <div class="sect2">
8406 <h3 id="pointer_cast_rationale">Rationale</h3>
8407 <div class="paragraph">
8408 <p>Boost smart pointers usually overload those functions to provide a mechanism
8409 to emulate pointers casts. For example, <code>shared_ptr&lt;T&gt;</code> implements a static
8410 pointer cast this way:</p>
8411 </div>
8412 <div class="listingblock">
8413 <div class="content">
8414 <pre class="highlight"><code>template&lt;class T, class U&gt;
8415   shared_ptr&lt;T&gt; static_pointer_cast(const shared_ptr&lt;U&gt;&amp; p);</code></pre>
8416 </div>
8417 </div>
8418 <div class="paragraph">
8419 <p>Pointer cast functions templates are overloads of <code>static_pointer_cast</code>,
8420 <code>dynamic_pointer_cast</code>, <code>const_pointer_cast</code>, and <code>reinterpret_pointer_cast</code>
8421 for raw pointers, <code>std::shared_ptr</code> and <code>std::unique_ptr</code>. This way when
8422 developing pointer type independent classes, for example, memory managers or
8423 shared memory compatible classes, the same code can be used for raw and smart
8424 pointers.</p>
8425 </div>
8426 </div>
8427 <div class="sect2">
8428 <h3 id="pointer_cast_synopsis">Synopsis</h3>
8429 <div class="paragraph">
8430 <p>The generic pointer casts are defined in <code>&lt;boost/pointer_cast.hpp&gt;</code>.</p>
8431 </div>
8432 <div class="listingblock">
8433 <div class="content">
8434 <pre class="highlight"><code>namespace boost {
8435   template&lt;class T, class U&gt; T* static_pointer_cast(U* p) noexcept;
8436   template&lt;class T, class U&gt; T* dynamic_pointer_cast(U* p) noexcept;
8437   template&lt;class T, class U&gt; T* const_pointer_cast(U* p) noexcept;
8438   template&lt;class T, class U&gt; T* reinterpret_pointer_cast(U* p) noexcept;
8439
8440   template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8441     static_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;
8442   template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8443     dynamic_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;
8444   template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8445     const_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;
8446   template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8447     reinterpret_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;
8448
8449   template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8450     static_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;
8451   template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8452     dynamic_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;
8453   template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8454     const_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;
8455   template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8456     reinterpret_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;
8457 }</code></pre>
8458 </div>
8459 </div>
8460 </div>
8461 <div class="sect2">
8462 <h3 id="pointer_cast_free_functions">Free Functions</h3>
8463 <div class="sect3">
8464 <h4 id="pointer_cast_static_pointer_cast">static_pointer_cast</h4>
8465 <div class="listingblock">
8466 <div class="content">
8467 <pre class="highlight"><code>template&lt;class T, class U&gt; T* static_pointer_cast(U* p) noexcept;</code></pre>
8468 </div>
8469 </div>
8470 <div class="ulist none">
8471 <ul class="none">
8472 <li>
8473 <p></p>
8474 <div class="dlist">
8475 <dl>
8476 <dt class="hdlist1">Returns</dt>
8477 <dd>
8478 <p><code>static_cast&lt;T*&gt;(p)</code></p>
8479 </dd>
8480 </dl>
8481 </div>
8482 </li>
8483 </ul>
8484 </div>
8485 <div class="listingblock">
8486 <div class="content">
8487 <pre class="highlight"><code>template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8488   static_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;</code></pre>
8489 </div>
8490 </div>
8491 <div class="ulist none">
8492 <ul class="none">
8493 <li>
8494 <p></p>
8495 <div class="dlist">
8496 <dl>
8497 <dt class="hdlist1">Returns</dt>
8498 <dd>
8499 <p><code>std::static_pointer_cast&lt;T&gt;(p)</code></p>
8500 </dd>
8501 </dl>
8502 </div>
8503 </li>
8504 </ul>
8505 </div>
8506 <div class="listingblock">
8507 <div class="content">
8508 <pre class="highlight"><code>template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8509   static_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;</code></pre>
8510 </div>
8511 </div>
8512 <div class="ulist none">
8513 <ul class="none">
8514 <li>
8515 <p></p>
8516 <div class="dlist">
8517 <dl>
8518 <dt class="hdlist1">Requires</dt>
8519 <dd>
8520 <p>The expression <code>static_cast&lt;T*&gt;((U*)0)</code> must be well-formed.</p>
8521 </dd>
8522 <dt class="hdlist1">Returns</dt>
8523 <dd>
8524 <p><code>std::unique_ptr&lt;T&gt;(static_cast&lt;typename
8525 std::unique_ptr&lt;T&gt;::element_type*&gt;(p.release()))</code>.</p>
8526 </dd>
8527 </dl>
8528 </div>
8529 </li>
8530 </ul>
8531 </div>
8532 <div class="admonitionblock caution">
8533 <table>
8534 <tr>
8535 <td class="icon">
8536 <div class="title">Caution</div>
8537 </td>
8538 <td class="content">
8539 The seemingly equivalent expression
8540 <code>std::unique_ptr&lt;T&gt;(static_cast&lt;T*&gt;(p.get()))</code> will eventually result in
8541 undefined behavior, attempting to delete the same object twice.
8542 </td>
8543 </tr>
8544 </table>
8545 </div>
8546 </div>
8547 <div class="sect3">
8548 <h4 id="pointer_cast_dynamic_pointer_cast">dynamic_pointer_cast</h4>
8549 <div class="listingblock">
8550 <div class="content">
8551 <pre class="highlight"><code>template&lt;class T, class U&gt; T* dynamic_pointer_cast(U* p) noexcept;</code></pre>
8552 </div>
8553 </div>
8554 <div class="ulist none">
8555 <ul class="none">
8556 <li>
8557 <p></p>
8558 <div class="dlist">
8559 <dl>
8560 <dt class="hdlist1">Returns</dt>
8561 <dd>
8562 <p><code>dynamic_cast&lt;T*&gt;(p)</code></p>
8563 </dd>
8564 </dl>
8565 </div>
8566 </li>
8567 </ul>
8568 </div>
8569 <div class="listingblock">
8570 <div class="content">
8571 <pre class="highlight"><code>template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8572   dynamic_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;</code></pre>
8573 </div>
8574 </div>
8575 <div class="ulist none">
8576 <ul class="none">
8577 <li>
8578 <p></p>
8579 <div class="dlist">
8580 <dl>
8581 <dt class="hdlist1">Returns</dt>
8582 <dd>
8583 <p><code>std::dynamic_pointer_cast&lt;T&gt;(p)</code></p>
8584 </dd>
8585 </dl>
8586 </div>
8587 </li>
8588 </ul>
8589 </div>
8590 <div class="listingblock">
8591 <div class="content">
8592 <pre class="highlight"><code>template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8593   dynamic_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;</code></pre>
8594 </div>
8595 </div>
8596 <div class="ulist none">
8597 <ul class="none">
8598 <li>
8599 <p></p>
8600 <div class="dlist">
8601 <dl>
8602 <dt class="hdlist1">Requires</dt>
8603 </dl>
8604 </div>
8605 </li>
8606 <li>
8607 <p>The expression <code>static_cast&lt;T*&gt;((U*)0)</code> must be well-formed.</p>
8608 </li>
8609 <li>
8610 <p><code>T</code> must have a virtual destructor.</p>
8611 <div class="dlist">
8612 <dl>
8613 <dt class="hdlist1">Returns</dt>
8614 </dl>
8615 </div>
8616 </li>
8617 <li>
8618 <p>When <code>dynamic_cast&lt;typename std::unique_ptr&lt;T&gt;::element_type*&gt;(p.get())</code>
8619 returns a non-zero value, <code>std::unique_ptr&lt;T&gt;(dynamic_cast&lt;typename
8620 std::unique_ptr&lt;T&gt;::element_type*&gt;(p.release()));</code>.</p>
8621 </li>
8622 <li>
8623 <p>Otherwise, <code>std::unique_ptr&lt;T&gt;()</code>.</p>
8624 </li>
8625 </ul>
8626 </div>
8627 </div>
8628 <div class="sect3">
8629 <h4 id="pointer_cast_const_pointer_cast">const_pointer_cast</h4>
8630 <div class="listingblock">
8631 <div class="content">
8632 <pre class="highlight"><code>template&lt;class T, class U&gt; T* const_pointer_cast(U* p) noexcept;</code></pre>
8633 </div>
8634 </div>
8635 <div class="ulist none">
8636 <ul class="none">
8637 <li>
8638 <p></p>
8639 <div class="dlist">
8640 <dl>
8641 <dt class="hdlist1">Returns</dt>
8642 <dd>
8643 <p><code>const_cast&lt;T*&gt;(p)</code></p>
8644 </dd>
8645 </dl>
8646 </div>
8647 </li>
8648 </ul>
8649 </div>
8650 <div class="listingblock">
8651 <div class="content">
8652 <pre class="highlight"><code>template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8653   const_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;</code></pre>
8654 </div>
8655 </div>
8656 <div class="ulist none">
8657 <ul class="none">
8658 <li>
8659 <p></p>
8660 <div class="dlist">
8661 <dl>
8662 <dt class="hdlist1">Returns</dt>
8663 <dd>
8664 <p><code>std::const_pointer_cast&lt;T&gt;(p)</code></p>
8665 </dd>
8666 </dl>
8667 </div>
8668 </li>
8669 </ul>
8670 </div>
8671 <div class="listingblock">
8672 <div class="content">
8673 <pre class="highlight"><code>template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8674   const_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;</code></pre>
8675 </div>
8676 </div>
8677 <div class="ulist none">
8678 <ul class="none">
8679 <li>
8680 <p></p>
8681 <div class="dlist">
8682 <dl>
8683 <dt class="hdlist1">Requires</dt>
8684 <dd>
8685 <p>The expression <code>const_cast&lt;T*&gt;((U*)0)</code> must be well-formed.</p>
8686 </dd>
8687 <dt class="hdlist1">Returns</dt>
8688 <dd>
8689 <p><code>std::unique_ptr&lt;T&gt;(const_cast&lt;typename
8690 std::unique_ptr&lt;T&gt;::element_type*&gt;(p.release()))</code>.</p>
8691 </dd>
8692 </dl>
8693 </div>
8694 </li>
8695 </ul>
8696 </div>
8697 </div>
8698 <div class="sect3">
8699 <h4 id="pointer_cast_reinterpret_pointer_cast">reinterpret_pointer_cast</h4>
8700 <div class="listingblock">
8701 <div class="content">
8702 <pre class="highlight"><code>template&lt;class T, class U&gt; T* reinterpret_pointer_cast(U* p) noexcept;</code></pre>
8703 </div>
8704 </div>
8705 <div class="ulist none">
8706 <ul class="none">
8707 <li>
8708 <p></p>
8709 <div class="dlist">
8710 <dl>
8711 <dt class="hdlist1">Returns</dt>
8712 <dd>
8713 <p><code>reinterpret_cast&lt;T*&gt;(p)</code></p>
8714 </dd>
8715 </dl>
8716 </div>
8717 </li>
8718 </ul>
8719 </div>
8720 <div class="listingblock">
8721 <div class="content">
8722 <pre class="highlight"><code>template&lt;class T, class U&gt; std::shared_ptr&lt;T&gt;
8723   reinterpret_pointer_cast(const std::shared_ptr&lt;U&gt;&amp; p) noexcept;</code></pre>
8724 </div>
8725 </div>
8726 <div class="ulist none">
8727 <ul class="none">
8728 <li>
8729 <p></p>
8730 <div class="dlist">
8731 <dl>
8732 <dt class="hdlist1">Returns</dt>
8733 <dd>
8734 <p><code>std::reinterpret_pointer_cast&lt;T&gt;(p)</code></p>
8735 </dd>
8736 </dl>
8737 </div>
8738 </li>
8739 </ul>
8740 </div>
8741 <div class="listingblock">
8742 <div class="content">
8743 <pre class="highlight"><code>template&lt;class T, class U&gt; std::unique_ptr&lt;T&gt;
8744   reinterpret_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; p) noexcept;</code></pre>
8745 </div>
8746 </div>
8747 <div class="ulist none">
8748 <ul class="none">
8749 <li>
8750 <p></p>
8751 <div class="dlist">
8752 <dl>
8753 <dt class="hdlist1">Requires</dt>
8754 <dd>
8755 <p>The expression <code>reinterpret_cast&lt;T*&gt;((U*)0)</code> must be well-formed.</p>
8756 </dd>
8757 <dt class="hdlist1">Returns</dt>
8758 <dd>
8759 <p><code>std::unique_ptr&lt;T&gt;(reinterpret_cast&lt;typename
8760 std::unique_ptr&lt;T&gt;::element_type*&gt;(p.release()))</code>.</p>
8761 </dd>
8762 </dl>
8763 </div>
8764 </li>
8765 </ul>
8766 </div>
8767 </div>
8768 </div>
8769 <div class="sect2">
8770 <h3 id="pointer_cast_example">Example</h3>
8771 <div class="paragraph">
8772 <p>The following example demonstrates how the generic pointer casts help us
8773 create pointer independent code.</p>
8774 </div>
8775 <div class="listingblock">
8776 <div class="content">
8777 <pre class="highlight"><code>#include &lt;boost/pointer_cast.hpp&gt;
8778 #include &lt;boost/shared_ptr.hpp&gt;
8779
8780 class base {
8781 public:
8782   virtual ~base() { }
8783 };
8784
8785 class derived : public base { };
8786
8787 template&lt;class Ptr&gt;
8788 void check_if_it_is_derived(const Ptr&amp; ptr)
8789 {
8790   assert(boost::dynamic_pointer_cast&lt;derived&gt;(ptr) != 0);
8791 }
8792
8793 int main()
8794 {
8795   base* ptr = new derived;
8796   boost::shared_ptr&lt;base&gt; sptr(new derived);
8797
8798   check_if_it_is_derived(ptr);
8799   check_if_it_is_derived(sptr);
8800
8801   delete ptr;
8802 }</code></pre>
8803 </div>
8804 </div>
8805 </div>
8806 </div>
8807 </div>
8808 <div class="sect1">
8809 <h2 id="pointer_to_other">pointer_to_other</h2>
8810 <div class="sectionbody">
8811 <div class="sect2">
8812 <h3 id="pointer_to_other_description">Description</h3>
8813 <div class="paragraph">
8814 <p>The <code>pointer_to_other</code> utility provides a way, given a source pointer type, to obtain a pointer of the same type
8815 to another pointee type.</p>
8816 </div>
8817 <div class="paragraph">
8818 <p>There is test/example code in <a href="../../test/pointer_to_other_test.cpp">pointer_to_other_test.cpp</a>.</p>
8819 </div>
8820 </div>
8821 <div class="sect2">
8822 <h3 id="pointer_to_other_rationale">Rationale</h3>
8823 <div class="paragraph">
8824 <p>When building pointer independent classes, like memory managers, allocators, or containers, there is often a need to
8825 define pointers generically, so that if a template parameter represents a pointer (for example, a raw or smart pointer
8826 to an <code>int</code>), we can define another pointer of the same type to another pointee (a raw or smart pointer to a <code>float</code>.)</p>
8827 </div>
8828 <div class="listingblock">
8829 <div class="content">
8830 <pre class="highlight"><code>template &lt;class IntPtr&gt; class FloatPointerHolder
8831 {
8832     // Let's define a pointer to a float
8833
8834     typedef typename boost::pointer_to_other
8835         &lt;IntPtr, float&gt;::type float_ptr_t;
8836
8837     float_ptr_t float_ptr;
8838 };</code></pre>
8839 </div>
8840 </div>
8841 </div>
8842 <div class="sect2">
8843 <h3 id="pointer_to_other_synopsis">Synopsis</h3>
8844 <div class="paragraph">
8845 <p><code>pointer_to_other</code> is defined in <code>&lt;boost/smart_ptr/pointer_to_other.hpp&gt;</code>.</p>
8846 </div>
8847 <div class="listingblock">
8848 <div class="content">
8849 <pre class="highlight"><code>namespace boost {
8850
8851   template&lt;class T, class U&gt; struct pointer_to_other;
8852
8853   template&lt;class T, class U,
8854     template &lt;class&gt; class Sp&gt;
8855       struct pointer_to_other&lt; Sp&lt;T&gt;, U &gt;
8856   {
8857     typedef Sp&lt;U&gt; type;
8858   };
8859
8860   template&lt;class T, class T2, class U,
8861     template &lt;class, class&gt; class Sp&gt;
8862       struct pointer_to_other&lt; Sp&lt;T, T2&gt;, U &gt;
8863   {
8864     typedef Sp&lt;U, T2&gt; type;
8865   };
8866
8867   template&lt;class T, class T2, class T3, class U,
8868     template &lt;class, class, class&gt; class Sp&gt;
8869       struct pointer_to_other&lt; Sp&lt;T, T2, T3&gt;, U &gt;
8870   {
8871     typedef Sp&lt;U, T2, T3&gt; type;
8872   };
8873
8874   template&lt;class T, class U&gt;
8875     struct pointer_to_other&lt; T*, U &gt;
8876   {
8877     typedef U* type;
8878   };
8879 }</code></pre>
8880 </div>
8881 </div>
8882 <div class="paragraph">
8883 <p>If these definitions are not correct for a specific smart pointer, we can define a specialization of <code>pointer_to_other</code>.</p>
8884 </div>
8885 </div>
8886 <div class="sect2">
8887 <h3 id="pointer_to_other_example">Example</h3>
8888 <div class="listingblock">
8889 <div class="content">
8890 <pre class="highlight"><code>// Let's define a memory allocator that can
8891 // work with raw and smart pointers
8892
8893 #include &lt;boost/pointer_to_other.hpp&gt;
8894
8895 template &lt;class VoidPtr&gt;
8896 class memory_allocator
8897 {
8898     // Predefine a memory_block
8899
8900     struct block;
8901
8902     // Define a pointer to a memory_block from a void pointer
8903     // If VoidPtr is void *, block_ptr_t is block*
8904     // If VoidPtr is smart_ptr&lt;void&gt;, block_ptr_t is smart_ptr&lt;block&gt;
8905
8906     typedef typename boost::pointer_to_other
8907         &lt;VoidPtr, block&gt;::type block_ptr_t;
8908
8909     struct block
8910     {
8911         std::size_t size;
8912         block_ptr_t next_block;
8913     };
8914
8915     block_ptr_t free_blocks;
8916 };</code></pre>
8917 </div>
8918 </div>
8919 <div class="paragraph">
8920 <p>As we can see, using <code>pointer_to_other</code> we can create pointer independent code.</p>
8921 </div>
8922 </div>
8923 </div>
8924 </div>
8925 <div class="sect1">
8926 <h2 id="atomic_shared_ptr">atomic_shared_ptr</h2>
8927 <div class="sectionbody">
8928 <div class="sect2">
8929 <h3 id="atomic_shared_ptr_description">Description</h3>
8930 <div class="paragraph">
8931 <p>The class template <code>atomic_shared_ptr&lt;T&gt;</code> implements the interface of <code>std::atomic</code>
8932 for a contained value of type <code>shared_ptr&lt;T&gt;</code>. Concurrent access to <code>atomic_shared_ptr</code>
8933 is not a data race.</p>
8934 </div>
8935 </div>
8936 <div class="sect2">
8937 <h3 id="atomic_shared_ptr_synopsis">Synopsis</h3>
8938 <div class="paragraph">
8939 <p><code>atomic_shared_ptr</code> is defined in <code>&lt;boost/smart_ptr/atomic_shared_ptr.hpp&gt;</code>.</p>
8940 </div>
8941 <div class="listingblock">
8942 <div class="content">
8943 <pre class="highlight"><code>namespace boost {
8944
8945   template&lt;class T&gt; class atomic_shared_ptr {
8946   private:
8947
8948     shared_ptr&lt;T&gt; p_; // exposition only
8949
8950     atomic_shared_ptr(const atomic_shared_ptr&amp;) = delete;
8951     atomic_shared_ptr&amp; operator=(const atomic_shared_ptr&amp;) = delete;
8952
8953   public:
8954
8955     constexpr atomic_shared_ptr() noexcept;
8956     atomic_shared_ptr( shared_ptr&lt;T&gt; p ) noexcept;
8957
8958     atomic_shared_ptr&amp; operator=( shared_ptr&lt;T&gt; r ) noexcept;
8959
8960     bool is_lock_free() const noexcept;
8961
8962     shared_ptr&lt;T&gt; load( int = 0 ) const noexcept;
8963     operator shared_ptr&lt;T&gt;() const noexcept;
8964
8965     void store( shared_ptr&lt;T&gt; r, int = 0 ) noexcept;
8966
8967     shared_ptr&lt;T&gt; exchange( shared_ptr&lt;T&gt; r, int = 0 ) noexcept;
8968
8969     bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int, int ) noexcept;
8970     bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int = 0 ) noexcept;
8971     bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int, int ) noexcept;
8972     bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int = 0 ) noexcept;
8973
8974     bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int, int ) noexcept;
8975     bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int = 0 ) noexcept;
8976     bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int, int ) noexcept;
8977     bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int = 0 ) noexcept;
8978   };
8979 }</code></pre>
8980 </div>
8981 </div>
8982 </div>
8983 <div class="sect2">
8984 <h3 id="atomic_shared_ptr_members">Members</h3>
8985 <div class="listingblock">
8986 <div class="content">
8987 <pre class="highlight"><code>constexpr atomic_shared_ptr() noexcept;</code></pre>
8988 </div>
8989 </div>
8990 <div class="ulist none">
8991 <ul class="none">
8992 <li>
8993 <p></p>
8994 <div class="dlist">
8995 <dl>
8996 <dt class="hdlist1">Effects</dt>
8997 <dd>
8998 <p>Default-initializes <code>p_</code>.</p>
8999 </dd>
9000 </dl>
9001 </div>
9002 </li>
9003 </ul>
9004 </div>
9005 <div class="listingblock">
9006 <div class="content">
9007 <pre class="highlight"><code>atomic_shared_ptr( shared_ptr&lt;T&gt; p ) noexcept;</code></pre>
9008 </div>
9009 </div>
9010 <div class="ulist none">
9011 <ul class="none">
9012 <li>
9013 <p></p>
9014 <div class="dlist">
9015 <dl>
9016 <dt class="hdlist1">Effects</dt>
9017 <dd>
9018 <p>Initializes <code>p_</code> to <code>p</code>.</p>
9019 </dd>
9020 </dl>
9021 </div>
9022 </li>
9023 </ul>
9024 </div>
9025 <div class="listingblock">
9026 <div class="content">
9027 <pre class="highlight"><code>atomic_shared_ptr&amp; operator=( shared_ptr&lt;T&gt; r ) noexcept;</code></pre>
9028 </div>
9029 </div>
9030 <div class="ulist none">
9031 <ul class="none">
9032 <li>
9033 <p></p>
9034 <div class="dlist">
9035 <dl>
9036 <dt class="hdlist1">Effects</dt>
9037 <dd>
9038 <p><code>p_.swap(r)</code>.</p>
9039 </dd>
9040 <dt class="hdlist1">Returns</dt>
9041 <dd>
9042 <p><code>*this</code>.</p>
9043 </dd>
9044 </dl>
9045 </div>
9046 </li>
9047 </ul>
9048 </div>
9049 <div class="listingblock">
9050 <div class="content">
9051 <pre class="highlight"><code>bool is_lock_free() const noexcept;</code></pre>
9052 </div>
9053 </div>
9054 <div class="ulist none">
9055 <ul class="none">
9056 <li>
9057 <p></p>
9058 <div class="dlist">
9059 <dl>
9060 <dt class="hdlist1">Returns</dt>
9061 <dd>
9062 <p><code>false</code>.</p>
9063 </dd>
9064 </dl>
9065 </div>
9066 </li>
9067 </ul>
9068 </div>
9069 <div class="admonitionblock note">
9070 <table>
9071 <tr>
9072 <td class="icon">
9073 <div class="title">Note</div>
9074 </td>
9075 <td class="content">
9076 This implementation is not lock-free.
9077 </td>
9078 </tr>
9079 </table>
9080 </div>
9081 <div class="listingblock">
9082 <div class="content">
9083 <pre class="highlight"><code>shared_ptr&lt;T&gt; load( int = 0 ) const noexcept;</code></pre>
9084 </div>
9085 </div>
9086 <div class="listingblock">
9087 <div class="content">
9088 <pre class="highlight"><code>operator shared_ptr&lt;T&gt;() const noexcept;</code></pre>
9089 </div>
9090 </div>
9091 <div class="ulist none">
9092 <ul class="none">
9093 <li>
9094 <p></p>
9095 <div class="dlist">
9096 <dl>
9097 <dt class="hdlist1">Returns</dt>
9098 <dd>
9099 <p><code>p_</code>.</p>
9100 </dd>
9101 </dl>
9102 </div>
9103 </li>
9104 </ul>
9105 </div>
9106 <div class="admonitionblock note">
9107 <table>
9108 <tr>
9109 <td class="icon">
9110 <div class="title">Note</div>
9111 </td>
9112 <td class="content">
9113 The <code>int</code> argument is intended to be of type <code>memory_order</code>, but is ignored.
9114   This implementation is lock-based and therefore always sequentially consistent.
9115 </td>
9116 </tr>
9117 </table>
9118 </div>
9119 <div class="listingblock">
9120 <div class="content">
9121 <pre class="highlight"><code>void store( shared_ptr&lt;T&gt; r, int = 0 ) noexcept;</code></pre>
9122 </div>
9123 </div>
9124 <div class="ulist none">
9125 <ul class="none">
9126 <li>
9127 <p></p>
9128 <div class="dlist">
9129 <dl>
9130 <dt class="hdlist1">Effects</dt>
9131 <dd>
9132 <p><code>p_.swap(r)</code>.</p>
9133 </dd>
9134 </dl>
9135 </div>
9136 </li>
9137 </ul>
9138 </div>
9139 <div class="listingblock">
9140 <div class="content">
9141 <pre class="highlight"><code>shared_ptr&lt;T&gt; exchange( shared_ptr&lt;T&gt; r, int = 0 ) noexcept;</code></pre>
9142 </div>
9143 </div>
9144 <div class="ulist none">
9145 <ul class="none">
9146 <li>
9147 <p></p>
9148 <div class="dlist">
9149 <dl>
9150 <dt class="hdlist1">Effects</dt>
9151 <dd>
9152 <p><code>p_.swap(r)</code>.</p>
9153 </dd>
9154 <dt class="hdlist1">Returns</dt>
9155 <dd>
9156 <p>The old value of <code>p_</code>.</p>
9157 </dd>
9158 </dl>
9159 </div>
9160 </li>
9161 </ul>
9162 </div>
9163 <div class="listingblock">
9164 <div class="content">
9165 <pre class="highlight"><code>bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int, int ) noexcept;</code></pre>
9166 </div>
9167 </div>
9168 <div class="listingblock">
9169 <div class="content">
9170 <pre class="highlight"><code>bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int = 0 ) noexcept;</code></pre>
9171 </div>
9172 </div>
9173 <div class="listingblock">
9174 <div class="content">
9175 <pre class="highlight"><code>bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int, int ) noexcept;</code></pre>
9176 </div>
9177 </div>
9178 <div class="listingblock">
9179 <div class="content">
9180 <pre class="highlight"><code>bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, const shared_ptr&lt;T&gt;&amp; w, int = 0 ) noexcept;</code></pre>
9181 </div>
9182 </div>
9183 <div class="ulist none">
9184 <ul class="none">
9185 <li>
9186 <p></p>
9187 <div class="dlist">
9188 <dl>
9189 <dt class="hdlist1">Effects</dt>
9190 <dd>
9191 <p>If <code>p_</code> is equivalent to <code>v</code>, assigns <code>w</code> to <code>p_</code>, otherwise assigns <code>p_</code> to <code>v</code>.</p>
9192 </dd>
9193 <dt class="hdlist1">Returns</dt>
9194 <dd>
9195 <p><code>true</code> if <code>p_</code> was equivalent to <code>v</code>, <code>false</code> otherwise.</p>
9196 </dd>
9197 <dt class="hdlist1">Remarks</dt>
9198 <dd>
9199 <p>Two <code>shared_ptr</code> instances are equivalent if they store the same pointer value and <em>share ownership</em>.</p>
9200 </dd>
9201 </dl>
9202 </div>
9203 </li>
9204 </ul>
9205 </div>
9206 <div class="listingblock">
9207 <div class="content">
9208 <pre class="highlight"><code>bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int, int ) noexcept;</code></pre>
9209 </div>
9210 </div>
9211 <div class="listingblock">
9212 <div class="content">
9213 <pre class="highlight"><code>bool compare_exchange_weak( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int = 0 ) noexcept;</code></pre>
9214 </div>
9215 </div>
9216 <div class="listingblock">
9217 <div class="content">
9218 <pre class="highlight"><code>bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int, int ) noexcept;</code></pre>
9219 </div>
9220 </div>
9221 <div class="listingblock">
9222 <div class="content">
9223 <pre class="highlight"><code>bool compare_exchange_strong( shared_ptr&lt;T&gt;&amp; v, shared_ptr&lt;T&gt;&amp;&amp; w, int = 0 ) noexcept;</code></pre>
9224 </div>
9225 </div>
9226 <div class="ulist none">
9227 <ul class="none">
9228 <li>
9229 <p></p>
9230 <div class="dlist">
9231 <dl>
9232 <dt class="hdlist1">Effects</dt>
9233 <dd>
9234 <p>If <code>p_</code> is equivalent to <code>v</code>, assigns <code>std::move(w)</code> to <code>p_</code>, otherwise assigns <code>p_</code> to <code>v</code>.</p>
9235 </dd>
9236 <dt class="hdlist1">Returns</dt>
9237 <dd>
9238 <p><code>true</code> if <code>p_</code> was equivalent to <code>v</code>, <code>false</code> otherwise.</p>
9239 </dd>
9240 <dt class="hdlist1">Remarks</dt>
9241 <dd>
9242 <p>The old value of <code>w</code> is not preserved in either case.</p>
9243 </dd>
9244 </dl>
9245 </div>
9246 </li>
9247 </ul>
9248 </div>
9249 </div>
9250 </div>
9251 </div>
9252 <div class="sect1">
9253 <h2 id="techniques">Appendix A: Smart Pointer Programming Techniques</h2>
9254 <div class="sectionbody">
9255 <div class="sect2">
9256 <h3 id="techniques_incomplete">Using incomplete classes for implementation hiding</h3>
9257 <div class="paragraph">
9258 <p>A proven technique (that works in C, too) for separating interface from implementation is to use a pointer to an incomplete class as an opaque handle:</p>
9259 </div>
9260 <div class="listingblock">
9261 <div class="content">
9262 <pre class="highlight"><code>class FILE;
9263
9264 FILE * fopen(char const * name, char const * mode);
9265 void fread(FILE * f, void * data, size_t size);
9266 void fclose(FILE * f);</code></pre>
9267 </div>
9268 </div>
9269 <div class="paragraph">
9270 <p>It is possible to express the above interface using <code>shared_ptr</code>, eliminating the need to manually call <code>fclose</code>:</p>
9271 </div>
9272 <div class="listingblock">
9273 <div class="content">
9274 <pre class="highlight"><code>class FILE;
9275
9276 shared_ptr&lt;FILE&gt; fopen(char const * name, char const * mode);
9277 void fread(shared_ptr&lt;FILE&gt; f, void * data, size_t size);</code></pre>
9278 </div>
9279 </div>
9280 <div class="paragraph">
9281 <p>This technique relies on <code>shared_ptr</code>&#8217;s ability to execute a custom deleter, eliminating the explicit call to <code>fclose</code>, and on the fact that <code>shared_ptr&lt;X&gt;</code> can be copied and destroyed when <code>X</code> is incomplete.</p>
9282 </div>
9283 </div>
9284 <div class="sect2">
9285 <h3 id="techniques_the_pimpl_idiom">The "Pimpl" idiom</h3>
9286 <div class="paragraph">
9287 <p>A C&#43;&#43; specific variation of the incomplete class pattern is the "Pimpl" idiom. The incomplete class is not exposed to the user; it is hidden behind a forwarding facade. <code>shared_ptr</code> can be used to implement a "Pimpl":</p>
9288 </div>
9289 <div class="listingblock">
9290 <div class="content">
9291 <pre class="highlight"><code>// file.hpp:
9292
9293 class file
9294 {
9295 private:
9296
9297     class impl;
9298     shared_ptr&lt;impl&gt; pimpl_;
9299
9300 public:
9301
9302     file(char const * name, char const * mode);
9303
9304     // compiler generated members are fine and useful
9305
9306     void read(void * data, size_t size);
9307 };
9308
9309 // file.cpp:
9310
9311 #include "file.hpp"
9312
9313 class file::impl
9314 {
9315 private:
9316
9317     impl(impl const &amp;);
9318     impl &amp; operator=(impl const &amp;);
9319
9320     // private data
9321
9322 public:
9323
9324     impl(char const * name, char const * mode) { ... }
9325     ~impl() { ... }
9326     void read(void * data, size_t size) { ... }
9327 };
9328
9329 file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
9330 {
9331 }
9332
9333 void file::read(void * data, size_t size)
9334 {
9335     pimpl_-&gt;read(data, size);
9336 }</code></pre>
9337 </div>
9338 </div>
9339 <div class="paragraph">
9340 <p>The key thing to note here is that the compiler-generated copy constructor, assignment operator, and destructor all have a sensible meaning. As a result, <code>file</code> is <code>CopyConstructible</code> and <code>Assignable</code>, allowing its use in standard containers.</p>
9341 </div>
9342 </div>
9343 <div class="sect2">
9344 <h3 id="techniques_using_abstract_classes_for_implementation_hiding">Using abstract classes for implementation hiding</h3>
9345 <div class="paragraph">
9346 <p>Another widely used C++ idiom for separating inteface and implementation is to use abstract base classes and factory functions.
9347 The abstract classes are sometimes called "interfaces" and the pattern is known as "interface-based programming". Again,
9348 <code>shared_ptr</code> can be used as the return type of the factory functions:</p>
9349 </div>
9350 <div class="listingblock">
9351 <div class="content">
9352 <pre class="highlight"><code>// X.hpp:
9353
9354 class X
9355 {
9356 public:
9357
9358     virtual void f() = 0;
9359     virtual void g() = 0;
9360
9361 protected:
9362
9363     ~X() {}
9364 };
9365
9366 shared_ptr&lt;X&gt; createX();
9367
9368 // X.cpp:
9369
9370 class X_impl: public X
9371 {
9372 private:
9373
9374     X_impl(X_impl const &amp;);
9375     X_impl &amp; operator=(X_impl const &amp;);
9376
9377 public:
9378
9379     virtual void f()
9380     {
9381       // ...
9382     }
9383
9384     virtual void g()
9385     {
9386       // ...
9387     }
9388 };
9389
9390 shared_ptr&lt;X&gt; createX()
9391 {
9392     shared_ptr&lt;X&gt; px(new X_impl);
9393     return px;
9394 }</code></pre>
9395 </div>
9396 </div>
9397 <div class="paragraph">
9398 <p>A key property of <code>shared_ptr</code> is that the allocation, construction, deallocation, and destruction details are captured at the point of construction, inside the factory function.</p>
9399 </div>
9400 <div class="paragraph">
9401 <p>Note the protected and nonvirtual destructor in the example above. The client code cannot, and does not need to, delete a pointer to <code>X</code>; the <code>shared_ptr&lt;X&gt;</code> instance returned from <code>createX</code> will correctly call <code>~X_impl</code>.</p>
9402 </div>
9403 </div>
9404 <div class="sect2">
9405 <h3 id="techniques_preventing_delete_px_get">Preventing <code>delete px.get()</code></h3>
9406 <div class="paragraph">
9407 <p>It is often desirable to prevent client code from deleting a pointer that is being managed by <code>shared_ptr</code>. The previous technique showed one possible approach, using a protected destructor. Another alternative is to use a private deleter:</p>
9408 </div>
9409 <div class="listingblock">
9410 <div class="content">
9411 <pre class="highlight"><code>class X
9412 {
9413 private:
9414
9415     ~X();
9416
9417     class deleter;
9418     friend class deleter;
9419
9420     class deleter
9421     {
9422     public:
9423
9424         void operator()(X * p) { delete p; }
9425     };
9426
9427 public:
9428
9429     static shared_ptr&lt;X&gt; create()
9430     {
9431         shared_ptr&lt;X&gt; px(new X, X::deleter());
9432         return px;
9433     }
9434 };</code></pre>
9435 </div>
9436 </div>
9437 </div>
9438 <div class="sect2">
9439 <h3 id="techniques_encapsulating_allocation_details_wrapping_factory_functions">Encapsulating allocation details, wrapping factory functions</h3>
9440 <div class="paragraph">
9441 <p><code>shared_ptr</code> can be used in creating C&#43;&#43; wrappers over existing C style library interfaces that return raw pointers from their factory functions
9442 to encapsulate allocation details. As an example, consider this interface, where <code>CreateX</code> might allocate <code>X</code> from its own private heap, <code>~X</code> may
9443 be inaccessible, or <code>X</code> may be incomplete:</p>
9444 </div>
9445 <div class="literalblock">
9446 <div class="content">
9447 <pre>X * CreateX();
9448 void DestroyX(X *);</pre>
9449 </div>
9450 </div>
9451 <div class="paragraph">
9452 <p>The only way to reliably destroy a pointer returned by <code>CreateX</code> is to call <code>DestroyX</code>.</p>
9453 </div>
9454 <div class="paragraph">
9455 <p>Here is how a <code>shared_ptr</code>-based wrapper may look like:</p>
9456 </div>
9457 <div class="literalblock">
9458 <div class="content">
9459 <pre>shared_ptr&lt;X&gt; createX()
9460 {
9461     shared_ptr&lt;X&gt; px(CreateX(), DestroyX);
9462     return px;
9463 }</pre>
9464 </div>
9465 </div>
9466 <div class="paragraph">
9467 <p>Client code that calls <code>createX</code> still does not need to know how the object has been allocated, but now the destruction is automatic.</p>
9468 </div>
9469 </div>
9470 <div class="sect2">
9471 <h3 id="techniques_static">Using a shared_ptr to hold a pointer to a statically allocated object</h3>
9472 <div class="paragraph">
9473 <p>Sometimes it is desirable to create a <code>shared_ptr</code> to an already existing object, so that the <code>shared_ptr</code> does not attempt to destroy the
9474 object when there are no more references left. As an example, the factory function:</p>
9475 </div>
9476 <div class="literalblock">
9477 <div class="content">
9478 <pre>shared_ptr&lt;X&gt; createX();</pre>
9479 </div>
9480 </div>
9481 <div class="paragraph">
9482 <p>in certain situations may need to return a pointer to a statically allocated <code>X</code> instance.</p>
9483 </div>
9484 <div class="paragraph">
9485 <p>The solution is to use a custom deleter that does nothing:</p>
9486 </div>
9487 <div class="listingblock">
9488 <div class="content">
9489 <pre class="highlight"><code>struct null_deleter
9490 {
9491     void operator()(void const *) const
9492     {
9493     }
9494 };
9495
9496 static X x;
9497
9498 shared_ptr&lt;X&gt; createX()
9499 {
9500     shared_ptr&lt;X&gt; px(&amp;x, null_deleter());
9501     return px;
9502 }</code></pre>
9503 </div>
9504 </div>
9505 <div class="paragraph">
9506 <p>The same technique works for any object known to outlive the pointer.</p>
9507 </div>
9508 </div>
9509 <div class="sect2">
9510 <h3 id="techniques_using_a_shared_ptr_to_hold_a_pointer_to_a_com_object">Using a shared_ptr to hold a pointer to a COM Object</h3>
9511 <div class="paragraph">
9512 <p>Background: COM objects have an embedded reference count and two member functions that manipulate it. <code>AddRef()</code> increments the count.
9513 <code>Release()</code> decrements the count and destroys itself when the count drops to zero.</p>
9514 </div>
9515 <div class="paragraph">
9516 <p>It is possible to hold a pointer to a COM object in a <code>shared_ptr</code>:</p>
9517 </div>
9518 <div class="literalblock">
9519 <div class="content">
9520 <pre>shared_ptr&lt;IWhatever&gt; make_shared_from_COM(IWhatever * p)
9521 {
9522     p-&gt;AddRef();
9523     shared_ptr&lt;IWhatever&gt; pw(p, mem_fn(&amp;IWhatever::Release));
9524     return pw;
9525 }</pre>
9526 </div>
9527 </div>
9528 <div class="paragraph">
9529 <p>Note, however, that <code>shared_ptr</code> copies created from <code>pw</code> will not "register" in the embedded count of the COM object;
9530 they will share the single reference created in <code>make_shared_from_COM</code>. Weak pointers created from <code>pw</code> will be invalidated when the last
9531 <code>shared_ptr</code> is destroyed, regardless of whether the COM object itself is still alive.</p>
9532 </div>
9533 <div class="paragraph">
9534 <p>As <a href="../../../../libs/bind/mem_fn.html#Q3">explained</a> in the <code>mem_fn</code> documentation, you need to <code>#define BOOST_MEM_FN_ENABLE_STDCALL</code> first.</p>
9535 </div>
9536 </div>
9537 <div class="sect2">
9538 <h3 id="techniques_intrusive">Using a shared_ptr to hold a pointer to an object with an embedded reference count</h3>
9539 <div class="paragraph">
9540 <p>This is a generalization of the above technique. The example assumes that the object implements the two functions required by <code><a href="#intrusive_ptr">intrusive_ptr</a></code>,
9541 <code>intrusive_ptr_add_ref</code> and <code>intrusive_ptr_release</code>:</p>
9542 </div>
9543 <div class="listingblock">
9544 <div class="content">
9545 <pre class="highlight"><code>template&lt;class T&gt; struct intrusive_deleter
9546 {
9547     void operator()(T * p)
9548     {
9549         if(p) intrusive_ptr_release(p);
9550     }
9551 };
9552
9553 shared_ptr&lt;X&gt; make_shared_from_intrusive(X * p)
9554 {
9555     if(p) intrusive_ptr_add_ref(p);
9556     shared_ptr&lt;X&gt; px(p, intrusive_deleter&lt;X&gt;());
9557     return px;
9558 }</code></pre>
9559 </div>
9560 </div>
9561 </div>
9562 <div class="sect2">
9563 <h3 id="techniques_using_a_shared_ptr_to_hold_another_shared_ownership_smart_pointer">Using a shared_ptr to hold another shared ownership smart pointer</h3>
9564 <div class="paragraph">
9565 <p>One of the design goals of <code>shared_ptr</code> is to be used in library interfaces. It is possible to encounter a situation where a library takes a
9566 <code>shared_ptr</code> argument, but the object at hand is being managed by a different reference counted or linked smart pointer.</p>
9567 </div>
9568 <div class="paragraph">
9569 <p>It is possible to exploit <code>shared_ptr</code>&#8217;s custom deleter feature to wrap this existing smart pointer behind a <code>shared_ptr</code> facade:</p>
9570 </div>
9571 <div class="listingblock">
9572 <div class="content">
9573 <pre class="highlight"><code>template&lt;class P&gt; struct smart_pointer_deleter
9574 {
9575 private:
9576
9577     P p_;
9578
9579 public:
9580
9581     smart_pointer_deleter(P const &amp; p): p_(p)
9582     {
9583     }
9584
9585     void operator()(void const *)
9586     {
9587         p_.reset();
9588     }
9589
9590     P const &amp; get() const
9591     {
9592         return p_;
9593     }
9594 };
9595
9596 shared_ptr&lt;X&gt; make_shared_from_another(another_ptr&lt;X&gt; qx)
9597 {
9598     shared_ptr&lt;X&gt; px(qx.get(), smart_pointer_deleter&lt; another_ptr&lt;X&gt; &gt;(qx));
9599     return px;
9600 }</code></pre>
9601 </div>
9602 </div>
9603 <div class="paragraph">
9604 <p>One subtle point is that deleters are not allowed to throw exceptions, and the above example as written assumes that <code>p_.reset()</code> doesn&#8217;t throw.
9605 If this is not the case, <code>p_.reset();</code> should be wrapped in a <code>try {} catch(&#8230;&#8203;) {}</code> block that ignores exceptions. In the (usually unlikely) event
9606 when an exception is thrown and ignored, <code>p_</code> will be released when the lifetime of the deleter ends. This happens when all references, including
9607 weak pointers, are destroyed or reset.</p>
9608 </div>
9609 <div class="paragraph">
9610 <p>Another twist is that it is possible, given the above <code>shared_ptr</code> instance, to recover the original smart pointer, using <code><a href="#shared_ptr_get_deleter">get_deleter</a></code>:</p>
9611 </div>
9612 <div class="listingblock">
9613 <div class="content">
9614 <pre class="highlight"><code>void extract_another_from_shared(shared_ptr&lt;X&gt; px)
9615 {
9616     typedef smart_pointer_deleter&lt; another_ptr&lt;X&gt; &gt; deleter;
9617
9618     if(deleter const * pd = get_deleter&lt;deleter&gt;(px))
9619     {
9620         another_ptr&lt;X&gt; qx = pd-&gt;get();
9621     }
9622     else
9623     {
9624         // not one of ours
9625     }
9626 }</code></pre>
9627 </div>
9628 </div>
9629 </div>
9630 <div class="sect2">
9631 <h3 id="techniques_from_raw">Obtaining a shared_ptr from a raw pointer</h3>
9632 <div class="paragraph">
9633 <p>Sometimes it is necessary to obtain a <code>shared_ptr</code> given a raw pointer to an object that is already managed by another <code>shared_ptr</code> instance. Example:</p>
9634 </div>
9635 <div class="literalblock">
9636 <div class="content">
9637 <pre>void f(X * p)
9638 {
9639     shared_ptr&lt;X&gt; px(???);
9640 }</pre>
9641 </div>
9642 </div>
9643 <div class="paragraph">
9644 <p>Inside <code>f</code>, we&#8217;d like to create a <code>shared_ptr</code> to <code>*p</code>.</p>
9645 </div>
9646 <div class="paragraph">
9647 <p>In the general case, this problem has no solution. One approach is to modify <code>f</code> to take a <code>shared_ptr</code>, if possible:</p>
9648 </div>
9649 <div class="literalblock">
9650 <div class="content">
9651 <pre>void f(shared_ptr&lt;X&gt; px);</pre>
9652 </div>
9653 </div>
9654 <div class="paragraph">
9655 <p>The same transformation can be used for nonvirtual member functions, to convert the implicit <code>this</code>:</p>
9656 </div>
9657 <div class="literalblock">
9658 <div class="content">
9659 <pre>void X::f(int m);</pre>
9660 </div>
9661 </div>
9662 <div class="paragraph">
9663 <p>would become a free function with a <code>shared_ptr</code> first argument:</p>
9664 </div>
9665 <div class="literalblock">
9666 <div class="content">
9667 <pre>void f(shared_ptr&lt;X&gt; this_, int m);</pre>
9668 </div>
9669 </div>
9670 <div class="paragraph">
9671 <p>If <code>f</code> cannot be changed, but <code>X</code> uses intrusive counting, use <code><a href="#techniques_intrusive">make_shared_from_intrusive</a></code> described above. Or, if it&#8217;s known that the <code>shared_ptr</code> created in <code>f</code> will never outlive the object, use <a href="#techniques_static">a null deleter</a>.</p>
9672 </div>
9673 </div>
9674 <div class="sect2">
9675 <h3 id="techniques_obtaining_a_shared_ptr_weak_ptr_to_this_in_a_constructor">Obtaining a shared_ptr (weak_ptr) to this in a constructor</h3>
9676 <div class="paragraph">
9677 <p>Some designs require objects to register themselves on construction with a central authority. When the registration routines take a <code>shared_ptr</code>, this leads to the question how could a constructor obtain a <code>shared_ptr</code> to <code>this</code>:</p>
9678 </div>
9679 <div class="listingblock">
9680 <div class="content">
9681 <pre class="highlight"><code>class X
9682 {
9683 public:
9684
9685     X()
9686     {
9687         shared_ptr&lt;X&gt; this_(???);
9688     }
9689 };</code></pre>
9690 </div>
9691 </div>
9692 <div class="paragraph">
9693 <p>In the general case, the problem cannot be solved. The <code>X</code> instance being constructed can be an automatic variable or a static variable; it can be created on the heap:</p>
9694 </div>
9695 <div class="literalblock">
9696 <div class="content">
9697 <pre>shared_ptr&lt;X&gt; px(new X);</pre>
9698 </div>
9699 </div>
9700 <div class="paragraph">
9701 <p>but at construction time, <code>px</code> does not exist yet, and it is impossible to create another <code>shared_ptr</code> instance that shares ownership with it.</p>
9702 </div>
9703 <div class="paragraph">
9704 <p>Depending on context, if the inner <code>shared_ptr this_</code> doesn&#8217;t need to keep the object alive, use a <code>null_deleter</code> as explained <a href="#techniques_static">here</a> and <a href="#techniques_weak_without_shared">here</a>.
9705 If <code>X</code> is supposed to always live on the heap, and be managed by a <code>shared_ptr</code>, use a static factory function:</p>
9706 </div>
9707 <div class="listingblock">
9708 <div class="content">
9709 <pre class="highlight"><code>class X
9710 {
9711 private:
9712
9713     X() { ... }
9714
9715 public:
9716
9717     static shared_ptr&lt;X&gt; create()
9718     {
9719         shared_ptr&lt;X&gt; px(new X);
9720         // use px as 'this_'
9721         return px;
9722     }
9723 };</code></pre>
9724 </div>
9725 </div>
9726 </div>
9727 <div class="sect2">
9728 <h3 id="techniques_obtaining_a_shared_ptr_to_this">Obtaining a shared_ptr to this</h3>
9729 <div class="paragraph">
9730 <p>Sometimes it is needed to obtain a <code>shared_ptr</code> from <code>this</code> in a virtual member function under the assumption that <code>this</code> is already managed by a <code>shared_ptr</code>.
9731 The transformations <a href="#techniques_from_raw">described in the previous technique</a> cannot be applied.</p>
9732 </div>
9733 <div class="paragraph">
9734 <p>A typical example:</p>
9735 </div>
9736 <div class="listingblock">
9737 <div class="content">
9738 <pre class="highlight"><code>class X
9739 {
9740 public:
9741
9742     virtual void f() = 0;
9743
9744 protected:
9745
9746     ~X() {}
9747 };
9748
9749 class Y
9750 {
9751 public:
9752
9753     virtual shared_ptr&lt;X&gt; getX() = 0;
9754
9755 protected:
9756
9757     ~Y() {}
9758 };
9759
9760 // --
9761
9762 class impl: public X, public Y
9763 {
9764 public:
9765
9766     impl() { ... }
9767
9768     virtual void f() { ... }
9769
9770     virtual shared_ptr&lt;X&gt; getX()
9771     {
9772         shared_ptr&lt;X&gt; px(???);
9773         return px;
9774     }
9775 };</code></pre>
9776 </div>
9777 </div>
9778 <div class="paragraph">
9779 <p>The solution is to keep a weak pointer to <code>this</code> as a member in <code>impl</code>:</p>
9780 </div>
9781 <div class="listingblock">
9782 <div class="content">
9783 <pre class="highlight"><code>class impl: public X, public Y
9784 {
9785 private:
9786
9787     weak_ptr&lt;impl&gt; weak_this;
9788
9789     impl(impl const &amp;);
9790     impl &amp; operator=(impl const &amp;);
9791
9792     impl() { ... }
9793
9794 public:
9795
9796     static shared_ptr&lt;impl&gt; create()
9797     {
9798         shared_ptr&lt;impl&gt; pi(new impl);
9799         pi-&gt;weak_this = pi;
9800         return pi;
9801     }
9802
9803     virtual void f() { ... }
9804
9805     virtual shared_ptr&lt;X&gt; getX()
9806     {
9807         shared_ptr&lt;X&gt; px(weak_this);
9808         return px;
9809     }
9810 };</code></pre>
9811 </div>
9812 </div>
9813 <div class="paragraph">
9814 <p>The library now includes a helper class template <code><a href="#enable_shared_from_this">enable_shared_from_this</a></code> that can be used to encapsulate the solution:</p>
9815 </div>
9816 <div class="listingblock">
9817 <div class="content">
9818 <pre class="highlight"><code>class impl: public X, public Y, public enable_shared_from_this&lt;impl&gt;
9819 {
9820 public:
9821
9822     impl(impl const &amp;);
9823     impl &amp; operator=(impl const &amp;);
9824
9825 public:
9826
9827     virtual void f() { ... }
9828
9829     virtual shared_ptr&lt;X&gt; getX()
9830     {
9831         return shared_from_this();
9832     }
9833 }</code></pre>
9834 </div>
9835 </div>
9836 <div class="paragraph">
9837 <p>Note that you no longer need to manually initialize the <code>weak_ptr</code> member in <code>enable_shared_from_this</code>. Constructing a <code>shared_ptr</code> to <code>impl</code> takes care of that.</p>
9838 </div>
9839 </div>
9840 <div class="sect2">
9841 <h3 id="techniques_using_shared_ptr_as_a_smart_counted_handle">Using shared_ptr as a smart counted handle</h3>
9842 <div class="paragraph">
9843 <p>Some library interfaces use opaque handles, a variation of the <a href="#techniques_incomplete">incomplete class technique</a> described above. An example:</p>
9844 </div>
9845 <div class="listingblock">
9846 <div class="content">
9847 <pre class="highlight"><code>typedef void * HANDLE;
9848
9849 HANDLE CreateProcess();
9850 void CloseHandle(HANDLE);</code></pre>
9851 </div>
9852 </div>
9853 <div class="paragraph">
9854 <p>Instead of a raw pointer, it is possible to use <code>shared_ptr</code> as the handle and get reference counting and automatic resource management for free:</p>
9855 </div>
9856 <div class="listingblock">
9857 <div class="content">
9858 <pre class="highlight"><code>typedef shared_ptr&lt;void&gt; handle;
9859
9860 handle createProcess()
9861 {
9862     shared_ptr&lt;void&gt; pv(CreateProcess(), CloseHandle);
9863     return pv;
9864 }</code></pre>
9865 </div>
9866 </div>
9867 </div>
9868 <div class="sect2">
9869 <h3 id="techniques_using_shared_ptr_to_execute_code_on_block_exit">Using shared_ptr to execute code on block exit</h3>
9870 <div class="paragraph">
9871 <p><code>shared_ptr&lt;void&gt;</code> can automatically execute cleanup code when control leaves a scope.</p>
9872 </div>
9873 <div class="ulist">
9874 <ul>
9875 <li>
9876 <p>Executing <code>f(p)</code>, where <code>p</code> is a pointer:</p>
9877 <div class="listingblock">
9878 <div class="content">
9879 <pre class="highlight"><code>shared_ptr&lt;void&gt; guard(p, f);</code></pre>
9880 </div>
9881 </div>
9882 </li>
9883 <li>
9884 <p>Executing arbitrary code: <code>f(x, y)</code>:</p>
9885 <div class="listingblock">
9886 <div class="content">
9887 <pre class="highlight"><code>shared_ptr&lt;void&gt; guard(static_cast&lt;void*&gt;(0), bind(f, x, y));</code></pre>
9888 </div>
9889 </div>
9890 </li>
9891 </ul>
9892 </div>
9893 </div>
9894 <div class="sect2">
9895 <h3 id="techniques_using_shared_ptrvoid_to_hold_an_arbitrary_object">Using shared_ptr&lt;void&gt; to hold an arbitrary object</h3>
9896 <div class="paragraph">
9897 <p><code>shared_ptr&lt;void&gt;</code> can act as a generic object pointer similar to <code>void*</code>. When a <code>shared_ptr&lt;void&gt;</code> instance constructed as:</p>
9898 </div>
9899 <div class="literalblock">
9900 <div class="content">
9901 <pre>shared_ptr&lt;void&gt; pv(new X);</pre>
9902 </div>
9903 </div>
9904 <div class="paragraph">
9905 <p>is destroyed, it will correctly dispose of the <code>X</code> object by executing <code>~X</code>.</p>
9906 </div>
9907 <div class="paragraph">
9908 <p>This propery can be used in much the same manner as a raw <code>void*</code> is used to temporarily strip type information from an object pointer.
9909 A <code>shared_ptr&lt;void&gt;</code> can later be cast back to the correct type by using <code><a href="#shared_ptr_static_pointer_cast">static_pointer_cast</a></code>.</p>
9910 </div>
9911 </div>
9912 <div class="sect2">
9913 <h3 id="techniques_associating_arbitrary_data_with_heterogeneous_shared_ptr_instances">Associating arbitrary data with heterogeneous <code>shared_ptr</code> instances</h3>
9914 <div class="paragraph">
9915 <p><code>shared_ptr</code> and <code>weak_ptr</code> support <code>operator&lt;</code> comparisons required by standard associative containers such as <code>std::map</code>. This can be
9916 used to non-intrusively associate arbitrary data with objects managed by <code>shared_ptr</code>:</p>
9917 </div>
9918 <div class="listingblock">
9919 <div class="content">
9920 <pre class="highlight"><code>typedef int Data;
9921
9922 std::map&lt;shared_ptr&lt;void&gt;, Data&gt; userData;
9923 // or std::map&lt;weak_ptr&lt;void&gt;, Data&gt; userData; to not affect the lifetime
9924
9925 shared_ptr&lt;X&gt; px(new X);
9926 shared_ptr&lt;int&gt; pi(new int(3));
9927
9928 userData[px] = 42;
9929 userData[pi] = 91;</code></pre>
9930 </div>
9931 </div>
9932 </div>
9933 <div class="sect2">
9934 <h3 id="techniques_using_shared_ptr_as_a_copyconstructible_mutex_lock">Using <code>shared_ptr</code> as a <code>CopyConstructible</code> mutex lock</h3>
9935 <div class="paragraph">
9936 <p>Sometimes it&#8217;s necessary to return a mutex lock from a function, and a noncopyable lock cannot be returned by value. It is possible to use <code>shared_ptr</code> as a mutex lock:</p>
9937 </div>
9938 <div class="listingblock">
9939 <div class="content">
9940 <pre class="highlight"><code>class mutex
9941 {
9942 public:
9943
9944     void lock();
9945     void unlock();
9946 };
9947
9948 shared_ptr&lt;mutex&gt; lock(mutex &amp; m)
9949 {
9950     m.lock();
9951     return shared_ptr&lt;mutex&gt;(&amp;m, mem_fn(&amp;mutex::unlock));
9952 }</code></pre>
9953 </div>
9954 </div>
9955 <div class="paragraph">
9956 <p>Better yet, the <code>shared_ptr</code> instance acting as a lock can be encapsulated in a dedicated <code>shared_lock</code> class:</p>
9957 </div>
9958 <div class="listingblock">
9959 <div class="content">
9960 <pre class="highlight"><code>class shared_lock
9961 {
9962 private:
9963
9964     shared_ptr&lt;void&gt; pv;
9965
9966 public:
9967
9968     template&lt;class Mutex&gt; explicit shared_lock(Mutex &amp; m): pv((m.lock(), &amp;m), mem_fn(&amp;Mutex::unlock)) {}
9969 };</code></pre>
9970 </div>
9971 </div>
9972 <div class="paragraph">
9973 <p><code>shared_lock</code> can now be used as:</p>
9974 </div>
9975 <div class="literalblock">
9976 <div class="content">
9977 <pre>shared_lock lock(m);</pre>
9978 </div>
9979 </div>
9980 <div class="paragraph">
9981 <p>Note that <code>shared_lock</code> is not templated on the mutex type, thanks to <code>shared_ptr&lt;void&gt;</code>&#8217;s ability to hide type information.</p>
9982 </div>
9983 </div>
9984 <div class="sect2">
9985 <h3 id="techniques_using_shared_ptr_to_wrap_member_function_calls">Using shared_ptr to wrap member function calls</h3>
9986 <div class="paragraph">
9987 <p><code>shared_ptr</code> implements the ownership semantics required from the <code>Wrap/CallProxy</code> scheme described in Bjarne Stroustrup&#8217;s article
9988 "Wrapping C++ Member Function Calls" (available online at <a href="http://www.stroustrup.com/wrapper.pdf" class="bare">http://www.stroustrup.com/wrapper.pdf</a>). An implementation is given below:</p>
9989 </div>
9990 <div class="listingblock">
9991 <div class="content">
9992 <pre class="highlight"><code>template&lt;class T&gt; class pointer
9993 {
9994 private:
9995
9996     T * p_;
9997
9998 public:
9999
10000     explicit pointer(T * p): p_(p)
10001     {
10002     }
10003
10004     shared_ptr&lt;T&gt; operator-&gt;() const
10005     {
10006         p_-&gt;prefix();
10007         return shared_ptr&lt;T&gt;(p_, mem_fn(&amp;T::suffix));
10008     }
10009 };
10010
10011 class X
10012 {
10013 private:
10014
10015     void prefix();
10016     void suffix();
10017     friend class pointer&lt;X&gt;;
10018
10019 public:
10020
10021     void f();
10022     void g();
10023 };
10024
10025 int main()
10026 {
10027     X x;
10028
10029     pointer&lt;X&gt; px(&amp;x);
10030
10031     px-&gt;f();
10032     px-&gt;g();
10033 }</code></pre>
10034 </div>
10035 </div>
10036 </div>
10037 <div class="sect2">
10038 <h3 id="techniques_delayed_deallocation">Delayed deallocation</h3>
10039 <div class="paragraph">
10040 <p>In some situations, a single <code>px.reset()</code> can trigger an expensive deallocation in a performance-critical region:</p>
10041 </div>
10042 <div class="listingblock">
10043 <div class="content">
10044 <pre class="highlight"><code>class X; // ~X is expensive
10045
10046 class Y
10047 {
10048     shared_ptr&lt;X&gt; px;
10049
10050 public:
10051
10052     void f()
10053     {
10054         px.reset();
10055     }
10056 };</code></pre>
10057 </div>
10058 </div>
10059 <div class="paragraph">
10060 <p>The solution is to postpone the potential deallocation by moving <code>px</code> to a dedicated free list that can be periodically emptied when performance and response times are not an issue:</p>
10061 </div>
10062 <div class="listingblock">
10063 <div class="content">
10064 <pre class="highlight"><code>vector&lt; shared_ptr&lt;void&gt; &gt; free_list;
10065
10066 class Y
10067 {
10068     shared_ptr&lt;X&gt; px;
10069
10070 public:
10071
10072     void f()
10073     {
10074         free_list.push_back(px);
10075         px.reset();
10076     }
10077 };
10078
10079 // periodically invoke free_list.clear() when convenient</code></pre>
10080 </div>
10081 </div>
10082 <div class="paragraph">
10083 <p>Another variation is to move the free list logic to the construction point by using a delayed deleter:</p>
10084 </div>
10085 <div class="listingblock">
10086 <div class="content">
10087 <pre class="highlight"><code>struct delayed_deleter
10088 {
10089     template&lt;class T&gt; void operator()(T * p)
10090     {
10091         try
10092         {
10093             shared_ptr&lt;void&gt; pv(p);
10094             free_list.push_back(pv);
10095         }
10096         catch(...)
10097         {
10098         }
10099     }
10100 };</code></pre>
10101 </div>
10102 </div>
10103 </div>
10104 <div class="sect2">
10105 <h3 id="techniques_weak_without_shared">Weak pointers to objects not managed by a shared_ptr</h3>
10106 <div class="paragraph">
10107 <p>Make the object hold a <code>shared_ptr</code> to itself, using a <code>null_deleter</code>:</p>
10108 </div>
10109 <div class="listingblock">
10110 <div class="content">
10111 <pre class="highlight"><code>class X
10112 {
10113 private:
10114
10115     shared_ptr&lt;X&gt; this_;
10116     int i_;
10117
10118 public:
10119
10120     explicit X(int i): this_(this, null_deleter()), i_(i)
10121     {
10122     }
10123
10124     // repeat in all constructors (including the copy constructor!)
10125
10126     X(X const &amp; rhs): this_(this, null_deleter()), i_(rhs.i_)
10127     {
10128     }
10129
10130     // do not forget to not assign this_ in the copy assignment
10131
10132     X &amp; operator=(X const &amp; rhs)
10133     {
10134         i_ = rhs.i_;
10135     }
10136
10137     weak_ptr&lt;X&gt; get_weak_ptr() const { return this_; }
10138 };</code></pre>
10139 </div>
10140 </div>
10141 <div class="paragraph">
10142 <p>When the object&#8217;s lifetime ends, <code>X::this_</code> will be destroyed, and all weak pointers will automatically expire.</p>
10143 </div>
10144 </div>
10145 </div>
10146 </div>
10147 <div class="sect1">
10148 <h2 id="history">Appendix B: History and Acknowledgments</h2>
10149 <div class="sectionbody">
10150 <div class="sect2">
10151 <h3 id="history_summer_1994">Summer 1994</h3>
10152 <div class="paragraph">
10153 <p>Greg Colvin <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1994/N0555.pdf">proposed</a>
10154 to the C&#43;&#43; Standards Committee classes named <code>auto_ptr</code> and <code>counted_ptr</code> which were very
10155 similar to what we now call <code>scoped_ptr</code> and <code>shared_ptr</code>. In one of the very few cases
10156 where the Library Working Group&#8217;s recommendations were not followed by the full committee,
10157 <code>counted_ptr</code> was rejected and surprising transfer-of-ownership semantics were added to <code>auto_ptr</code>.</p>
10158 </div>
10159 </div>
10160 <div class="sect2">
10161 <h3 id="history_october_1998">October 1998</h3>
10162 <div class="paragraph">
10163 <p>Beman Dawes proposed reviving the original semantics under the names <code>safe_ptr</code> and <code>counted_ptr</code>,
10164 meeting of Per Andersson, Matt Austern, Greg Colvin, Sean Corfield, Pete Becker, Nico Josuttis,
10165 Dietmar Kühl, Nathan Myers, Chichiang Wan and Judy Ward. During the discussion, the four new class
10166 names were finalized, it was decided that there was no need to exactly follow the <code>std::auto_ptr</code>
10167 interface, and various function signatures and semantics were finalized.</p>
10168 </div>
10169 <div class="paragraph">
10170 <p>Over the next three months, several implementations were considered for <code>shared_ptr</code>, and discussed
10171 on the <a href="http://www.boost.org/">boost.org</a> mailing list. The implementation questions revolved around
10172 the reference count which must be kept, either attached to the pointed to object, or detached elsewhere.
10173 Each of those variants have themselves two major variants:</p>
10174 </div>
10175 <div class="ulist">
10176 <ul>
10177 <li>
10178 <p>Direct detached: the <code>shared_ptr</code> contains a pointer to the object, and a pointer to the count.</p>
10179 </li>
10180 <li>
10181 <p>Indirect detached: the <code>shared_ptr</code> contains a pointer to a helper object, which in turn contains a pointer to the object and the count.</p>
10182 </li>
10183 <li>
10184 <p>Embedded attached: the count is a member of the object pointed to.</p>
10185 </li>
10186 <li>
10187 <p>Placement attached: the count is attached via operator new manipulations.</p>
10188 </li>
10189 </ul>
10190 </div>
10191 <div class="paragraph">
10192 <p>Each implementation technique has advantages and disadvantages. We went so far as to run various timings
10193 of the direct and indirect approaches, and found that at least on Intel Pentium chips there was very little
10194 measurable difference. Kevlin Henney provided a paper he wrote on "Counted Body Techniques." Dietmar Kühl
10195 suggested an elegant partial template specialization technique to allow users to choose which implementation
10196 they preferred, and that was also experimented with.</p>
10197 </div>
10198 <div class="paragraph">
10199 <p>But Greg Colvin and Jerry Schwarz argued that "parameterization will discourage users", and in the end we choose
10200 to supply only the direct implementation.</p>
10201 </div>
10202 </div>
10203 <div class="sect2">
10204 <h3 id="history_may_1999">May 1999</h3>
10205 <div class="paragraph">
10206 <p>In April and May, 1999, Valentin Bonnard and David Abrahams made a number of suggestions resulting in numerous improvements.</p>
10207 </div>
10208 </div>
10209 <div class="sect2">
10210 <h3 id="history_september_1999">September 1999</h3>
10211 <div class="paragraph">
10212 <p>Luis Coelho provided <code>shared_ptr::swap</code> and <code>shared_array::swap</code>.</p>
10213 </div>
10214 </div>
10215 <div class="sect2">
10216 <h3 id="history_november_1999">November 1999</h3>
10217 <div class="paragraph">
10218 <p>Darin Adler provided <code>operator ==</code>, <code>operator !=</code>, and <code>std::swap</code> and <code>std::less</code> specializations for shared types.</p>
10219 </div>
10220 </div>
10221 <div class="sect2">
10222 <h3 id="history_may_2001">May 2001</h3>
10223 <div class="paragraph">
10224 <p>Vladimir Prus suggested requiring a complete type on destruction. Refinement evolved in discussions including Dave Abrahams,
10225 Greg Colvin, Beman Dawes, Rainer Deyke, Peter Dimov, John Maddock, Vladimir Prus, Shankar Sai, and others.</p>
10226 </div>
10227 </div>
10228 <div class="sect2">
10229 <h3 id="history_january_2002">January 2002</h3>
10230 <div class="paragraph">
10231 <p>Peter Dimov reworked all four classes, adding features, fixing bugs, splitting them into four separate headers, and adding
10232 <code>weak_ptr</code>.</p>
10233 </div>
10234 </div>
10235 <div class="sect2">
10236 <h3 id="history_march_2003">March 2003</h3>
10237 <div class="paragraph">
10238 <p>Peter Dimov, Beman Dawes and Greg Colvin <a href="http://open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1450.html">proposed</a> <code>shared_ptr</code>
10239 and <code>weak_ptr</code> for inclusion in the Standard Library via the first Library Technical Report (known as TR1). The proposal was
10240 accepted and eventually went on to become a part of the C&#43;&#43; standard in its 2011 iteration.</p>
10241 </div>
10242 </div>
10243 <div class="sect2">
10244 <h3 id="history_july_2007">July 2007</h3>
10245 <div class="paragraph">
10246 <p>Peter Dimov and Beman Dawes <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2351.htm">proposed</a> a number of enhancements
10247 to <code>shared_ptr</code> as it was entering the working paper that eventually became the C&#43;&#43;11 standard.</p>
10248 </div>
10249 </div>
10250 <div class="sect2">
10251 <h3 id="history_november_2012">November 2012</h3>
10252 <div class="paragraph">
10253 <p>Glen Fernandes provided implementations of <code>make_shared</code> and <code>allocate_shared</code> for arrays. They achieve a single allocation
10254 for an array that can be initialized with constructor arguments or initializer lists as well as overloads for default initialization
10255 and no value initialization.</p>
10256 </div>
10257 <div class="paragraph">
10258 <p>Peter Dimov aided this development by extending <code>shared_ptr</code> to support arrays via the syntax <code>shared_ptr&lt;T[]&gt;</code> and <code>shared_ptr&lt;T[N]&gt;</code>.</p>
10259 </div>
10260 </div>
10261 <div class="sect2">
10262 <h3 id="history_april_2013">April 2013</h3>
10263 <div class="paragraph">
10264 <p>Peter Dimov <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3640.html">proposed</a> the extension of <code>shared_ptr</code> to support
10265 arrays for inclusion into the standard, and it was accepted.</p>
10266 </div>
10267 </div>
10268 <div class="sect2">
10269 <h3 id="history_february_2014">February 2014</h3>
10270 <div class="paragraph">
10271 <p>Glen Fernandes updated <code>make_shared</code> and <code>allocate_shared</code> to conform to the specification in C&#43;&#43; standard paper
10272 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3870.html">N3870</a>, and implemented <code>make_unique</code> for arrays and objects.</p>
10273 </div>
10274 <div class="paragraph">
10275 <p>Peter Dimov and Glen Fernandes updated the scalar and array implementations, respectively, to resolve C&#43;&#43; standard library defect 2070.</p>
10276 </div>
10277 </div>
10278 <div class="sect2">
10279 <h3 id="history_february_2017">February 2017</h3>
10280 <div class="paragraph">
10281 <p>Glen Fernandes rewrote <code>allocate_shared</code> and <code>make_shared</code> for arrays for a more optimal and more maintainable implementation.</p>
10282 </div>
10283 </div>
10284 <div class="sect2">
10285 <h3 id="history_june_2017">June 2017</h3>
10286 <div class="paragraph">
10287 <p>Peter Dimov and Glen Fernandes rewrote the documentation in Asciidoc format.</p>
10288 </div>
10289 <div class="paragraph">
10290 <p>Peter Dimov added <code>atomic_shared_ptr</code> and <code>local_shared_ptr</code>.</p>
10291 </div>
10292 </div>
10293 <div class="sect2">
10294 <h3 id="history_august_2019">August 2019</h3>
10295 <div class="paragraph">
10296 <p>Glen Fernandes implemented <code>allocate_unique</code> for scalars and arrays.</p>
10297 </div>
10298 </div>
10299 </div>
10300 </div>
10301 <div class="sect1">
10302 <h2 id="shared_array">Appendix C: shared_array (deprecated)</h2>
10303 <div class="sectionbody">
10304 <div class="admonitionblock note">
10305 <table>
10306 <tr>
10307 <td class="icon">
10308 <div class="title">Note</div>
10309 </td>
10310 <td class="content">
10311 This facility is deprecated because a <code>shared_ptr</code> to <code>T[]</code> or <code>T[N]</code>
10312 is now available, and is superior in every regard.
10313 </td>
10314 </tr>
10315 </table>
10316 </div>
10317 <div class="sect2">
10318 <h3 id="shared_array_description">Description</h3>
10319 <div class="paragraph">
10320 <p>The <code>shared_array</code> class template stores a pointer to a dynamically allocated
10321 array. (Dynamically allocated array are allocated with the C++ <code>new[]</code>
10322 expression.) The object pointed to is guaranteed to be deleted when the last
10323 <code>shared_array</code> pointing to it is destroyed or reset.</p>
10324 </div>
10325 <div class="paragraph">
10326 <p>Every <code>shared_array</code> meets the <em>CopyConstructible</em> and <em>Assignable</em>
10327 requirements of the C&#43;&#43; Standard Library, and so can be used in standard
10328 library containers. Comparison operators are supplied so that shared_array
10329 works with the standard library&#8217;s associative containers.</p>
10330 </div>
10331 <div class="paragraph">
10332 <p>Normally, a <code>shared_array</code> cannot correctly hold a pointer to an object that
10333 has been allocated with the non-array form of <code>new</code>. See <code>shared_ptr</code> for that
10334 usage.</p>
10335 </div>
10336 <div class="paragraph">
10337 <p>Because the implementation uses reference counting, cycles of <code>shared_array</code>
10338 instances will not be reclaimed. For example, if <code>main</code> holds a shared_array
10339 to <code>A</code>, which directly or indirectly holds a shared_array back to <code>A</code>, the use
10340 count of <code>A</code> will be 2. Destruction of the original <code>shared_array</code> will leave
10341 <code>A</code> dangling with a use count of 1.</p>
10342 </div>
10343 <div class="paragraph">
10344 <p>A <code>shared_ptr</code> to a <code>std::vector</code> is an alternative to a <code>shared_array</code> that
10345 is a bit heavier duty but far more flexible.</p>
10346 </div>
10347 <div class="paragraph">
10348 <p>The class template is parameterized on <code>T</code>, the type of the object pointed to.
10349 <code>shared_array</code> and most of its member functions place no requirements on <code>T</code>;
10350 it is allowed to be an incomplete type, or <code>void</code>. Member functions that do
10351 place additional requirements (constructors, reset) are explicitly documented
10352 below.</p>
10353 </div>
10354 </div>
10355 <div class="sect2">
10356 <h3 id="shared_array_synopsis">Synopsis</h3>
10357 <div class="listingblock">
10358 <div class="content">
10359 <pre class="highlight"><code>namespace boost {
10360
10361   template&lt;class T&gt; class shared_array {
10362   public:
10363     typedef T element_type;
10364
10365     explicit shared_array(T* p = 0);
10366     template&lt;class D&gt; shared_array(T* p, D d);
10367     shared_array(const shared_array&amp; v) noexcept;
10368
10369     ~shared_array() noexcept;
10370
10371     shared_array&amp; operator=(const shared_array&amp; v) noexcept;
10372
10373     void reset(T* p = 0);
10374     template&lt;class D&gt; void reset(T* p, D d);
10375
10376     T&amp; operator[](std::ptrdiff_t n) const noexcept;
10377     T* get() const noexcept;
10378
10379     bool unique() const noexcept;
10380     long use_count() const noexcept;
10381
10382     explicit operator bool() const noexcept;
10383
10384     void swap(shared_array&lt;T&gt;&amp; v) noexcept;
10385   };
10386
10387   template&lt;class T&gt; bool
10388     operator==(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b) noexcept;
10389   template&lt;class T&gt; bool
10390     operator!=(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b) noexcept;
10391   template&lt;class T&gt; bool
10392     operator&lt;(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b) noexcept;
10393
10394   template&lt;class T&gt;
10395     void swap(shared_array&lt;T&gt;&amp; a, shared_array&lt;T&gt;&amp; b) noexcept;
10396 }</code></pre>
10397 </div>
10398 </div>
10399 </div>
10400 <div class="sect2">
10401 <h3 id="shared_array_members">Members</h3>
10402 <div class="sect3">
10403 <h4 id="shared_array_element_type">element_type</h4>
10404 <div class="listingblock">
10405 <div class="content">
10406 <pre class="highlight"><code>typedef T element_type;</code></pre>
10407 </div>
10408 </div>
10409 <div class="dlist">
10410 <dl>
10411 <dt class="hdlist1">Type</dt>
10412 <dd>
10413 <p>Provides the type of the stored pointer.</p>
10414 </dd>
10415 </dl>
10416 </div>
10417 </div>
10418 <div class="sect3">
10419 <h4 id="shared_array_constructors">Constructors</h4>
10420 <div class="listingblock">
10421 <div class="content">
10422 <pre class="highlight"><code>explicit shared_array(T* p = 0);</code></pre>
10423 </div>
10424 </div>
10425 <div class="ulist none">
10426 <ul class="none">
10427 <li>
10428 <p></p>
10429 <div class="dlist">
10430 <dl>
10431 <dt class="hdlist1">Effects</dt>
10432 <dd>
10433 <p>Constructs a <code>shared_array</code>, storing a copy of <code>p</code>, which must be a
10434 pointer to an array that was allocated via a C++ <code>new[]</code> expression or be 0.
10435 Afterwards, the use count is 1 (even if <code>p == 0</code>; see <code>~shared_array</code>).</p>
10436 </dd>
10437 <dt class="hdlist1">Requires</dt>
10438 <dd>
10439 <p><code>T</code> is a complete type.</p>
10440 </dd>
10441 <dt class="hdlist1">Throws</dt>
10442 <dd>
10443 <p><code>std::bad_alloc</code>. If an exception is thrown, <code>delete[] p</code> is called.</p>
10444 </dd>
10445 </dl>
10446 </div>
10447 </li>
10448 </ul>
10449 </div>
10450 <div class="listingblock">
10451 <div class="content">
10452 <pre class="highlight"><code>template&lt;class D&gt; shared_array(T* p, D d);</code></pre>
10453 </div>
10454 </div>
10455 <div class="ulist none">
10456 <ul class="none">
10457 <li>
10458 <p></p>
10459 <div class="dlist">
10460 <dl>
10461 <dt class="hdlist1">Effects</dt>
10462 <dd>
10463 <p>Constructs a <code>shared_array</code>, storing a copy of <code>p</code> and of <code>d</code>.
10464 Afterwards, the use count is 1. When the the time comes to delete the array
10465 pointed to by <code>p</code>, the object <code>d</code> is used in the statement <code>d(p)</code>.</p>
10466 </dd>
10467 <dt class="hdlist1">Requires</dt>
10468 </dl>
10469 </div>
10470 </li>
10471 <li>
10472 <p><code>T</code> is a complete type.</p>
10473 </li>
10474 <li>
10475 <p>The copy constructor and destructor of <code>D</code> must not throw.</p>
10476 </li>
10477 <li>
10478 <p>Invoking the object <code>d</code> with parameter <code>p</code> must not throw.</p>
10479 <div class="dlist">
10480 <dl>
10481 <dt class="hdlist1">Throws</dt>
10482 <dd>
10483 <p><code>std::bad_alloc</code>. If an exception is thrown, <code>d(p)</code> is called.</p>
10484 </dd>
10485 </dl>
10486 </div>
10487 </li>
10488 </ul>
10489 </div>
10490 <div class="listingblock">
10491 <div class="content">
10492 <pre class="highlight"><code>shared_array(const shared_array&amp; v) noexcept;</code></pre>
10493 </div>
10494 </div>
10495 <div class="ulist none">
10496 <ul class="none">
10497 <li>
10498 <p></p>
10499 <div class="dlist">
10500 <dl>
10501 <dt class="hdlist1">Effects</dt>
10502 <dd>
10503 <p>Constructs a <code>shared_array</code>, as if by storing a copy of the pointer
10504 stored in <code>v</code>. Afterwards, the use count for all copies is 1 more than the
10505 initial use count.</p>
10506 </dd>
10507 <dt class="hdlist1">Requires</dt>
10508 <dd>
10509 <p><code>T</code> is a complete type.</p>
10510 </dd>
10511 </dl>
10512 </div>
10513 </li>
10514 </ul>
10515 </div>
10516 </div>
10517 <div class="sect3">
10518 <h4 id="shared_array_destructor">Destructor</h4>
10519 <div class="listingblock">
10520 <div class="content">
10521 <pre class="highlight"><code>~shared_array() noexcept;</code></pre>
10522 </div>
10523 </div>
10524 <div class="ulist none">
10525 <ul class="none">
10526 <li>
10527 <p></p>
10528 <div class="dlist">
10529 <dl>
10530 <dt class="hdlist1">Effects</dt>
10531 <dd>
10532 <p>Decrements the use count. Then, if the use count is 0, deletes the
10533 array pointed to by the stored pointer. Note that <code>delete[]</code> on a pointer with
10534 a value of 0 is harmless.</p>
10535 </dd>
10536 </dl>
10537 </div>
10538 </li>
10539 </ul>
10540 </div>
10541 </div>
10542 <div class="sect3">
10543 <h4 id="shared_array_assignment">Assignment</h4>
10544 <div class="listingblock">
10545 <div class="content">
10546 <pre class="highlight"><code>shared_array&amp; operator=(const shared_array&amp; v) noexcept;</code></pre>
10547 </div>
10548 </div>
10549 <div class="ulist none">
10550 <ul class="none">
10551 <li>
10552 <p></p>
10553 <div class="dlist">
10554 <dl>
10555 <dt class="hdlist1">Effects</dt>
10556 <dd>
10557 <p>Constructs a new <code>shared_array</code> as described above, then replaces
10558 this <code>shared_array</code> with the new one, destroying the replaced object.</p>
10559 </dd>
10560 <dt class="hdlist1">Requires</dt>
10561 <dd>
10562 <p><code>T</code> is a complete type.</p>
10563 </dd>
10564 <dt class="hdlist1">Returns</dt>
10565 <dd>
10566 <p><code>*this</code>.</p>
10567 </dd>
10568 </dl>
10569 </div>
10570 </li>
10571 </ul>
10572 </div>
10573 </div>
10574 <div class="sect3">
10575 <h4 id="shared_array_reset">reset</h4>
10576 <div class="listingblock">
10577 <div class="content">
10578 <pre class="highlight"><code>void reset(T* p = 0);</code></pre>
10579 </div>
10580 </div>
10581 <div class="ulist none">
10582 <ul class="none">
10583 <li>
10584 <p></p>
10585 <div class="dlist">
10586 <dl>
10587 <dt class="hdlist1">Effects</dt>
10588 <dd>
10589 <p>Constructs a new <code>shared_array</code> as described above, then replaces
10590 this <code>shared_array</code> with the new one, destroying the replaced object.</p>
10591 </dd>
10592 <dt class="hdlist1">Requires</dt>
10593 <dd>
10594 <p><code>T</code> is a complete type.</p>
10595 </dd>
10596 <dt class="hdlist1">Throws</dt>
10597 <dd>
10598 <p><code>std::bad_alloc</code>. If an exception is thrown, <code>delete[] p</code> is called.</p>
10599 </dd>
10600 </dl>
10601 </div>
10602 </li>
10603 </ul>
10604 </div>
10605 <div class="listingblock">
10606 <div class="content">
10607 <pre class="highlight"><code>template&lt;class D&gt; void reset(T* p, D d);</code></pre>
10608 </div>
10609 </div>
10610 <div class="ulist none">
10611 <ul class="none">
10612 <li>
10613 <p></p>
10614 <div class="dlist">
10615 <dl>
10616 <dt class="hdlist1">Effects</dt>
10617 <dd>
10618 <p>Constructs a new <code>shared_array</code> as described above, then replaces
10619 this <code>shared_array</code> with the new one, destroying the replaced object.</p>
10620 </dd>
10621 <dt class="hdlist1">Requires</dt>
10622 </dl>
10623 </div>
10624 </li>
10625 <li>
10626 <p><code>T</code> is a complete type.</p>
10627 </li>
10628 <li>
10629 <p>The copy constructor of <code>D</code> must not throw.</p>
10630 <div class="dlist">
10631 <dl>
10632 <dt class="hdlist1">Throws</dt>
10633 <dd>
10634 <p><code>std::bad_alloc</code>. If an exception is thrown, <code>d(p)</code> is called.</p>
10635 </dd>
10636 </dl>
10637 </div>
10638 </li>
10639 </ul>
10640 </div>
10641 </div>
10642 <div class="sect3">
10643 <h4 id="shared_array_indexing">Indexing</h4>
10644 <div class="listingblock">
10645 <div class="content">
10646 <pre class="highlight"><code>T&amp; operator[](std::ptrdiff_t n) const noexcept;</code></pre>
10647 </div>
10648 </div>
10649 <div class="dlist">
10650 <dl>
10651 <dt class="hdlist1">Returns</dt>
10652 <dd>
10653 <p>A reference to element <code>n</code> of the array pointed to by the stored
10654 pointer. Behavior is undefined and almost certainly undesirable if the stored
10655 pointer is 0, or if <code>n</code> is less than 0 or is greater than or equal to the
10656 number of elements in the array.</p>
10657 </dd>
10658 <dt class="hdlist1">Requires</dt>
10659 <dd>
10660 <p><code>T</code> is a complete type.</p>
10661 </dd>
10662 </dl>
10663 </div>
10664 </div>
10665 <div class="sect3">
10666 <h4 id="shared_array_get">get</h4>
10667 <div class="listingblock">
10668 <div class="content">
10669 <pre class="highlight"><code>T* get() const noexcept;</code></pre>
10670 </div>
10671 </div>
10672 <div class="ulist none">
10673 <ul class="none">
10674 <li>
10675 <p></p>
10676 <div class="dlist">
10677 <dl>
10678 <dt class="hdlist1">Returns</dt>
10679 <dd>
10680 <p>The stored pointer.</p>
10681 </dd>
10682 </dl>
10683 </div>
10684 </li>
10685 </ul>
10686 </div>
10687 </div>
10688 <div class="sect3">
10689 <h4 id="shared_array_unique">unique</h4>
10690 <div class="listingblock">
10691 <div class="content">
10692 <pre class="highlight"><code>bool unique() const noexcept;</code></pre>
10693 </div>
10694 </div>
10695 <div class="ulist none">
10696 <ul class="none">
10697 <li>
10698 <p></p>
10699 <div class="dlist">
10700 <dl>
10701 <dt class="hdlist1">Returns</dt>
10702 <dd>
10703 <p><code>true</code> if no other <code>shared_array</code> is sharing ownership of the
10704 stored pointer, <code>false</code> otherwise.</p>
10705 </dd>
10706 </dl>
10707 </div>
10708 </li>
10709 </ul>
10710 </div>
10711 </div>
10712 <div class="sect3">
10713 <h4 id="shared_array_use_count">use_count</h4>
10714 <div class="listingblock">
10715 <div class="content">
10716 <pre class="highlight"><code>long use_count() const noexcept;</code></pre>
10717 </div>
10718 </div>
10719 <div class="ulist none">
10720 <ul class="none">
10721 <li>
10722 <p></p>
10723 <div class="dlist">
10724 <dl>
10725 <dt class="hdlist1">Returns</dt>
10726 <dd>
10727 <p>The number of <code>shared_array</code> objects sharing ownership of the
10728 stored pointer.</p>
10729 </dd>
10730 </dl>
10731 </div>
10732 </li>
10733 </ul>
10734 </div>
10735 </div>
10736 <div class="sect3">
10737 <h4 id="shared_array_conversions">Conversions</h4>
10738 <div class="listingblock">
10739 <div class="content">
10740 <pre class="highlight"><code>explicit operator bool() const noexcept;</code></pre>
10741 </div>
10742 </div>
10743 <div class="ulist none">
10744 <ul class="none">
10745 <li>
10746 <p></p>
10747 <div class="dlist">
10748 <dl>
10749 <dt class="hdlist1">Returns</dt>
10750 <dd>
10751 <p><code>get() != 0</code>.</p>
10752 </dd>
10753 <dt class="hdlist1">Requires</dt>
10754 <dd>
10755 <p><code>T</code> is a complete type.</p>
10756 </dd>
10757 </dl>
10758 </div>
10759 </li>
10760 </ul>
10761 </div>
10762 </div>
10763 <div class="sect3">
10764 <h4 id="shared_array_swap">swap</h4>
10765 <div class="listingblock">
10766 <div class="content">
10767 <pre class="highlight"><code>void swap(shared_array&lt;T&gt;&amp; b) noexcept;</code></pre>
10768 </div>
10769 </div>
10770 <div class="ulist none">
10771 <ul class="none">
10772 <li>
10773 <p></p>
10774 <div class="dlist">
10775 <dl>
10776 <dt class="hdlist1">Effects</dt>
10777 <dd>
10778 <p>Exchanges the contents of the two smart pointers.</p>
10779 </dd>
10780 </dl>
10781 </div>
10782 </li>
10783 </ul>
10784 </div>
10785 </div>
10786 </div>
10787 <div class="sect2">
10788 <h3 id="shared_array_free_functions">Free Functions</h3>
10789 <div class="sect3">
10790 <h4 id="shared_array_comparison">Comparison</h4>
10791 <div class="listingblock">
10792 <div class="content">
10793 <pre class="highlight"><code>template&lt;class T&gt; bool
10794   operator==(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b) noexcept;</code></pre>
10795 </div>
10796 </div>
10797 <div class="listingblock">
10798 <div class="content">
10799 <pre class="highlight"><code>template&lt;class T&gt; bool
10800   operator!=(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b) noexcept;</code></pre>
10801 </div>
10802 </div>
10803 <div class="listingblock">
10804 <div class="content">
10805 <pre class="highlight"><code>template&lt;class T&gt; bool
10806   operator&lt;(const shared_array&lt;T&gt;&amp; a, const shared_array&lt;T&gt;&amp; b) noexcept;</code></pre>
10807 </div>
10808 </div>
10809 <div class="ulist none">
10810 <ul class="none">
10811 <li>
10812 <p></p>
10813 <div class="dlist">
10814 <dl>
10815 <dt class="hdlist1">Returns</dt>
10816 <dd>
10817 <p>The result of comparing the stored pointers of the two smart
10818 pointers.</p>
10819 </dd>
10820 </dl>
10821 </div>
10822 </li>
10823 </ul>
10824 </div>
10825 <div class="admonitionblock note">
10826 <table>
10827 <tr>
10828 <td class="icon">
10829 <div class="title">Note</div>
10830 </td>
10831 <td class="content">
10832 The <code>operator&lt;</code> overload is provided to define an ordering so that
10833 <code>shared_array</code> objects can be used in associative containers such as
10834 <code>std::map</code>. The implementation uses <code>std::less&lt;T*&gt;</code> to perform the comparison.
10835 This ensures that the comparison is handled correctly, since the standard
10836 mandates that relational operations on pointers are unspecified (5.9
10837 [expr.rel] paragraph 2) but <code>std::less</code> on pointers is well-defined (20.3.3
10838 [lib.comparisons] paragraph 8).
10839 </td>
10840 </tr>
10841 </table>
10842 </div>
10843 </div>
10844 <div class="sect3">
10845 <h4 id="shared_array_swap_2">swap</h4>
10846 <div class="listingblock">
10847 <div class="content">
10848 <pre class="highlight"><code>template&lt;class T&gt;
10849   void swap(shared_array&lt;T&gt;&amp; a, shared_array&lt;T&gt;&amp; b) noexcept;</code></pre>
10850 </div>
10851 </div>
10852 <div class="ulist none">
10853 <ul class="none">
10854 <li>
10855 <p></p>
10856 <div class="dlist">
10857 <dl>
10858 <dt class="hdlist1">Returns</dt>
10859 <dd>
10860 <p><code>a.swap(b)</code>.</p>
10861 </dd>
10862 <dt class="hdlist1">Requires</dt>
10863 <dd>
10864 <p><code>T</code> is a complete type.</p>
10865 </dd>
10866 </dl>
10867 </div>
10868 </li>
10869 </ul>
10870 </div>
10871 </div>
10872 </div>
10873 </div>
10874 </div>
10875 <div class="sect1">
10876 <h2 id="copyright">Appendix D: Copyright and License</h2>
10877 <div class="sectionbody">
10878 <div class="paragraph">
10879 <p>This documentation is</p>
10880 </div>
10881 <div class="ulist">
10882 <ul>
10883 <li>
10884 <p>Copyright 1999 Greg Colvin</p>
10885 </li>
10886 <li>
10887 <p>Copyright 1999 Beman Dawes</p>
10888 </li>
10889 <li>
10890 <p>Copyright 2002 Darin Adler</p>
10891 </li>
10892 <li>
10893 <p>Copyright 2003-2017 Peter Dimov</p>
10894 </li>
10895 <li>
10896 <p>Copyright 2005, 2006 Ion Gaztañaga</p>
10897 </li>
10898 <li>
10899 <p>Copyright 2008 Frank Mori Hess</p>
10900 </li>
10901 <li>
10902 <p>Copyright 2012-2017 Glen Fernandes</p>
10903 </li>
10904 <li>
10905 <p>Copyright 2013 Andrey Semashev</p>
10906 </li>
10907 </ul>
10908 </div>
10909 <div class="paragraph">
10910 <p>and is distributed under the <a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License, Version 1.0</a>.</p>
10911 </div>
10912 </div>
10913 </div>
10914 </div>
10915 <div id="footer">
10916 <div id="footer-text">
10917 Last updated 2019-12-10 00:19:52 UTC
10918 </div>
10919 </div>
10920 <style>
10921
10922 *:not(pre)>code { background: none; color: #600000; }
10923 table tr.even, table tr.alt, table tr:nth-of-type(even) { background: none; }
10924
10925 </style>
10926 </body>
10927 </html>