Topic: Use new keyword to indicate that a function
Author: mihailnajdenov@gmail.com
Date: Mon, 22 Oct 2018 01:23:58 -0700 (PDT)
Raw View
------=_Part_4444_79020814.1540196638656
Content-Type: multipart/alternative;
boundary="----=_Part_4445_1776134256.1540196638657"
------=_Part_4445_1776134256.1540196638657
Content-Type: text/plain; charset="UTF-8"
You must give better motivation.
If you want to use a function that returns an object and have that object
new-ed without copy/move, then you should explain what is stopping you
creating the returned object via the new expression in the first place,
especially now with template deduction guide.
If you want a copy/move of the object, returned by the function you can do
this today using new auto(create_object());
My guess is you want the former, but some better examples would be nice.
On Monday, October 22, 2018 at 7:43:42 AM UTC+3, sunsetburn...@gmail.com
wrote:
>
> We could write a function to take something allocated on the stack and
> return a copy of it on the heap:
>
> template<class T> T* as_new(T&& obj) {
> return new T{ std::forward<decltype(obj)>(obj)};
> }
>
> And this works in most cases while only incurring a performance hit.
> However, it breaks down when using objects that either can't be copied or
> moved. Providing overloads of functions that allocate something in a
> specific provided space can be tedious, too.
>
> *Proposal: *putting the new keyword in parethesis before a function or
> expression results in the output of that expression being allocated on the
> heap, or in the provided buffer.
>
> Let's take the function make_tuple as an example:
>
> #include <tuple>
> int main() {
> using std::tuple;
> using std::make_tuple;
>
> /* Allocates tuple normally */
> tuple<int, double> t1 = make_tuple(4, 0.3);
>
> /*Allocates tuple on heap, returns pointer */
> tuple<int, double>* t2 = (new) make_tuple(4, 0.3);
>
> char buff[100];
>
> /* Allocates tuple in buff, returns pointer */
> tuple<int, double>* t3 = (new(buff)) make_tuple(4, 0.3);
> }
>
>
> if a function returns a reference, it's a compiler error to use this
> construct, and if the function returns a pointer, then this construct
> returns a pointer to that pointer.
>
>
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40isocpp.org.
------=_Part_4445_1776134256.1540196638657
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">You must give better motivation.=C2=A0<div>If you want to =
use a function that returns an object and have that object new-ed without c=
opy/move, then you should explain what is stopping you creating the returne=
d object via the new expression in the first place, especially now with tem=
plate deduction guide.</div><div>If you want a copy/move of the object, ret=
urned by the function you can do this today using <font face=3D"courier new=
, monospace">new auto(create_object());</font><br><br>My guess is you want =
the former, but some better examples would be nice.</div><div><br><br>On Mo=
nday, October 22, 2018 at 7:43:42 AM UTC+3, sunsetburn...@gmail.com wrote:<=
blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;bord=
er-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr">We could write=
a function to take something allocated on the stack and return a copy of i=
t on the heap:<div><br></div><div><div style=3D"background-color:rgb(250,25=
0,250);border-color:rgb(187,187,187);border-style:solid;border-width:1px"><=
code><div><span style=3D"color:#008">template</span><span style=3D"color:#6=
60"><</span><span style=3D"color:#008">class</span><span style=3D"color:=
#000"> T</span><span style=3D"color:#660">></span><span style=3D"color:#=
000"> T</span><span style=3D"color:#660">*</span><span style=3D"color:#000"=
> as_new</span><span style=3D"color:#660">(</span><span style=3D"color:#000=
">T</span><span style=3D"color:#660">&&</span><span style=3D"color:=
#000"> obj</span><span style=3D"color:#660">)</span><span style=3D"color:#0=
00"> </span><span style=3D"color:#660">{</span><span style=3D"color:#000"><=
br>=C2=A0 =C2=A0 </span><span style=3D"color:#008">return</span><span style=
=3D"color:#000"> </span><span style=3D"color:#008">new</span><span style=3D=
"color:#000"> T</span><span style=3D"color:#660">{</span><span style=3D"col=
or:#000"> std</span><span style=3D"color:#660">::</span><font color=3D"#000=
000"><span style=3D"color:#000">forward</span><span style=3D"color:#660">&l=
t;</span><span style=3D"color:#008">decltype</span><span style=3D"color:#66=
0">(</span><span style=3D"color:#000">obj</span><span style=3D"color:#660">=
)></span></font><span style=3D"color:#660">(</span><span style=3D"color:=
#000">ob<wbr>j</span><span style=3D"color:#660">)};</span><span style=3D"co=
lor:#000"><br></span><span style=3D"color:#660">}</span><span style=3D"colo=
r:#000"><br></span></div></code></div><div><br></div>And this works in most=
cases while only incurring a performance hit. However, it breaks down when=
using objects that either can't be copied or moved. Providing overload=
s of functions that allocate something in a specific provided space can be =
tedious, too.=C2=A0</div><div><br></div><div><b>Proposal: </b>putting the n=
ew keyword in parethesis before a function or expression results in the out=
put of that expression being allocated on the heap, or in the provided buff=
er.=C2=A0</div><div><br></div><div>Let's take the function make_tuple a=
s an example:<br></div><div><br></div><div><div style=3D"background-color:r=
gb(250,250,250);border-color:rgb(187,187,187);border-style:solid;border-wid=
th:1px"><code><div><div style=3D"color:rgb(65,65,65);background-color:rgb(2=
51,251,251);font-family:"Droid Sans Mono",monospace,monospace,&qu=
ot;Droid Sans Fallback";font-size:14px;line-height:19px;white-space:pr=
e"><div style=3D"font-family:"Droid Sans Mono",monospace,monospac=
e,"Droid Sans Fallback";line-height:19px"><div><span style=3D"col=
or:#05ad97"><span style=3D"color:#800">#include</span></span><span style=3D=
"color:#000"> </span><span style=3D"color:#3d9ca9"><span style=3D"color:#08=
0"><tuple></span></span><span style=3D"color:#000"> </span></div><div=
><span style=3D"color:#d10771"><span style=3D"color:#008">int</span></span>=
<span style=3D"color:#000"> </span><span style=3D"color:#8d12ba"><span styl=
e=3D"color:#000">main</span></span><span style=3D"color:#660">()</span><spa=
n style=3D"color:#000"> </span><span style=3D"color:#660">{</span></div><di=
v><span style=3D"color:#000"> =C2=A0 =C2=A0</span><span style=3D"color:#05a=
d97"><span style=3D"color:#008">using</span></span><span style=3D"color:#00=
0"> std</span><span style=3D"color:#660">::</span><span style=3D"color:#000=
">tuple</span><span style=3D"color:#660">;</span></div><div><span style=3D"=
color:#000"> =C2=A0 =C2=A0</span><span style=3D"color:#05ad97"><span style=
=3D"color:#008">using</span></span><span style=3D"color:#000"> std</span><s=
pan style=3D"color:#660">::</span><span style=3D"color:#000">make_tuple</sp=
an><span style=3D"color:#660">;</span></div><span style=3D"color:#000"><br>=
</span><div><span style=3D"color:#000">=C2=A0 =C2=A0 </span><span style=3D"=
color:#555555;font-style:italic"><span style=3D"color:#800">/* Allocates tu=
ple normally */</span></span></div><div><span style=3D"color:#000"> =C2=A0 =
=C2=A0tuple</span><span style=3D"color:#4d4d4d"><span style=3D"color:#660">=
<</span></span><span style=3D"color:#d10771"><span style=3D"color:#008">=
int</span></span><span style=3D"color:#660">,</span><span style=3D"color:#0=
00"> </span><span style=3D"color:#d10771"><span style=3D"color:#008">double=
</span></span><span style=3D"color:#4d4d4d"><span style=3D"color:#660">>=
</span></span><span style=3D"color:#000"> t1 </span><span style=3D"color:#4=
d4d4d"><span style=3D"color:#660">=3D</span></span><span style=3D"color:#00=
0"> </span><span style=3D"color:#8d12ba"><span style=3D"color:#000">make_tu=
ple</span></span><span style=3D"color:#660">(</span><span style=3D"color:#c=
c5200"><span style=3D"color:#066">4</span></span><span style=3D"color:#660"=
>,</span><span style=3D"color:#000"> </span><span style=3D"color:#cc5200"><=
span style=3D"color:#066">0.3</span></span><span style=3D"color:#660">);</s=
pan></div><span style=3D"color:#000"><br></span><div><span style=3D"color:#=
000">=C2=A0 =C2=A0 </span><span style=3D"color:#555555;font-style:italic"><=
span style=3D"color:#800">/*Allocates tuple on heap, returns pointer */</sp=
an></span></div><div><span style=3D"color:#000"> =C2=A0 =C2=A0tuple</span><=
span style=3D"color:#4d4d4d"><span style=3D"color:#660"><</span></span><=
span style=3D"color:#d10771"><span style=3D"color:#008">int</span></span><s=
pan style=3D"color:#660">,</span><span style=3D"color:#000"> </span><span s=
tyle=3D"color:#d10771"><span style=3D"color:#008">double</span></span><span=
style=3D"color:#4d4d4d"><span style=3D"color:#660">>*</span></span><spa=
n style=3D"color:#000"> t2 </span><span style=3D"color:#4d4d4d"><span style=
=3D"color:#660">=3D</span></span><span style=3D"color:#000"> </span><span s=
tyle=3D"color:#660">(</span><span style=3D"color:#05ad97"><span style=3D"co=
lor:#008">new</span></span><span style=3D"color:#660">)</span><span style=
=3D"color:#000"> </span><span style=3D"color:#8d12ba"><span style=3D"color:=
#000">make_tuple</span></span><span style=3D"color:#660">(</span><span styl=
e=3D"color:#cc5200"><span style=3D"color:#066">4</span></span><span style=
=3D"color:#660">,</span><span style=3D"color:#000"> </span><span style=3D"c=
olor:#cc5200"><span style=3D"color:#066">0.3</span></span><span style=3D"co=
lor:#660">);</span><span style=3D"color:#000"> </span></div><span style=3D"=
color:#000"><br></span><div><span style=3D"color:#000">=C2=A0 =C2=A0 </span=
><span style=3D"color:#d10771"><span style=3D"color:#008">char</span></span=
><span style=3D"color:#000"> buff</span><span style=3D"color:#660">[</span>=
<span style=3D"color:#cc5200"><span style=3D"color:#066">100</span></span><=
span style=3D"color:#660">];</span></div><div><span style=3D"color:#000"> =
=C2=A0 =C2=A0</span></div><div><span style=3D"color:#000"> =C2=A0 =C2=A0</s=
pan><span style=3D"color:#555555;font-style:italic"><span style=3D"color:#8=
00">/* Allocates tuple in buff, returns pointer */</span></span></div><div>=
<span style=3D"color:#000"> =C2=A0 =C2=A0tuple</span><span style=3D"color:#=
4d4d4d"><span style=3D"color:#660"><</span></span><span style=3D"color:#=
d10771"><span style=3D"color:#008">int</span></span><span style=3D"color:#6=
60">,</span><span style=3D"color:#000"> </span><span style=3D"color:#d10771=
"><span style=3D"color:#008">double</span></span><span style=3D"color:#4d4d=
4d"><span style=3D"color:#660">>*</span></span><span style=3D"color:#000=
"> t3 </span><span style=3D"color:#4d4d4d"><span style=3D"color:#660">=3D</=
span></span><span style=3D"color:#000"> </span><span style=3D"color:#660">(=
</span><span style=3D"color:#8d12ba"><span style=3D"color:#008">new</span><=
/span><span style=3D"color:#660">(</span><span style=3D"color:#000">buff</s=
pan><span style=3D"color:#660">))</span><span style=3D"color:#000"> </span>=
<span style=3D"color:#8d12ba"><span style=3D"color:#000">make_tuple</span><=
/span><span style=3D"color:#660">(</span><span style=3D"color:#cc5200"><spa=
n style=3D"color:#066">4</span></span><span style=3D"color:#660">,</span><s=
pan style=3D"color:#000"> </span><span style=3D"color:#cc5200"><span style=
=3D"color:#066">0.3</span></span><span style=3D"color:#660">);</span></div>=
<div><span style=3D"color:#660">}</span></div><span style=3D"color:#000"><b=
r></span></div></div></div></code></div><br>if a function returns a referen=
ce, it's a compiler error to use this construct, and if the function re=
turns a pointer, then this construct returns a pointer to that pointer.=C2=
=A0</div><div><br></div><div><br></div></div></blockquote></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b=
%40isocpp.org</a>.<br />
------=_Part_4445_1776134256.1540196638657--
------=_Part_4444_79020814.1540196638656--
.
Author: Richard Smith <richard@metafoo.co.uk>
Date: Mon, 22 Oct 2018 19:30:36 -0700
Raw View
--00000000000045748f0578dc2896
Content-Type: text/plain; charset="UTF-8"
On Mon, 22 Oct 2018 at 01:23, <mihailnajdenov@gmail.com> wrote:
> You must give better motivation.
> If you want to use a function that returns an object and have that object
> new-ed without copy/move, then you should explain what is stopping you
> creating the returned object via the new expression in the first place,
> especially now with template deduction guide.
> If you want a copy/move of the object, returned by the function you can do
> this today using new auto(create_object());
>
If create_object() returns by value (as make_tuple does, for instance),
this does not perform a copy or move. Rather, it constructs directly into
the allocated storage. That is, we already have the feature that is being
requested here: just use 'new'.
My guess is you want the former, but some better examples would be nice.
>
>
> On Monday, October 22, 2018 at 7:43:42 AM UTC+3, sunsetburn...@gmail.com
> wrote:
>>
>> We could write a function to take something allocated on the stack and
>> return a copy of it on the heap:
>>
>> template<class T> T* as_new(T&& obj) {
>> return new T{ std::forward<decltype(obj)>(obj)};
>> }
>>
>> And this works in most cases while only incurring a performance hit.
>> However, it breaks down when using objects that either can't be copied or
>> moved. Providing overloads of functions that allocate something in a
>> specific provided space can be tedious, too.
>>
>> *Proposal: *putting the new keyword in parethesis before a function or
>> expression results in the output of that expression being allocated on the
>> heap, or in the provided buffer.
>>
>> Let's take the function make_tuple as an example:
>>
>> #include <tuple>
>> int main() {
>> using std::tuple;
>> using std::make_tuple;
>>
>> /* Allocates tuple normally */
>> tuple<int, double> t1 = make_tuple(4, 0.3);
>>
>> /*Allocates tuple on heap, returns pointer */
>> tuple<int, double>* t2 = (new) make_tuple(4, 0.3);
>>
>> char buff[100];
>>
>> /* Allocates tuple in buff, returns pointer */
>> tuple<int, double>* t3 = (new(buff)) make_tuple(4, 0.3);
>> }
>>
>>
>> if a function returns a reference, it's a compiler error to use this
>> construct, and if the function returns a pointer, then this construct
>> returns a pointer to that pointer.
>>
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit
> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40isocpp.org?utm_medium=email&utm_source=footer>
> .
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOfiQqnyH1r5e5QEKEgeSfa0pg3LbcVDb-URGLgGLap2f%2BJ68A%40mail.gmail.com.
--00000000000045748f0578dc2896
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><div class=3D"gmail_quote"><div dir=3D"ltr">On Mon, 22 Oct=
2018 at 01:23, <<a href=3D"mailto:mihailnajdenov@gmail.com">mihailnajde=
nov@gmail.com</a>> wrote:<br></div><blockquote class=3D"gmail_quote" sty=
le=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div d=
ir=3D"ltr">You must give better motivation.=C2=A0<div>If you want to use a =
function that returns an object and have that object new-ed without copy/mo=
ve, then you should explain what is stopping you creating the returned obje=
ct via the new expression in the first place, especially now with template =
deduction guide.</div><div>If you want a copy/move of the object, returned =
by the function you can do this today using <font face=3D"courier new, mono=
space">new auto(create_object());</font></div></div></blockquote><div><br><=
/div><div>If create_object() returns by value (as make_tuple does, for inst=
ance), this does not perform a copy or move. Rather, it constructs directly=
into the allocated storage. That is, we already have the feature that is b=
eing requested here: just use 'new'.</div><div><br></div><blockquot=
e class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc sol=
id;padding-left:1ex"><div dir=3D"ltr"><div>My guess is you want the former,=
but some better examples would be nice.</div><div><br><br>On Monday, Octob=
er 22, 2018 at 7:43:42 AM UTC+3, <a href=3D"mailto:sunsetburn...@gmail.com"=
target=3D"_blank">sunsetburn...@gmail.com</a> wrote:<blockquote class=3D"g=
mail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;=
padding-left:1ex"><div dir=3D"ltr">We could write a function to take someth=
ing allocated on the stack and return a copy of it on the heap:<div><br></d=
iv><div><div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px"><code><div><span style=3D"c=
olor:#008">template</span><span style=3D"color:#660"><</span><span style=
=3D"color:#008">class</span><span style=3D"color:#000"> T</span><span style=
=3D"color:#660">></span><span style=3D"color:#000"> T</span><span style=
=3D"color:#660">*</span><span style=3D"color:#000"> as_new</span><span styl=
e=3D"color:#660">(</span><span style=3D"color:#000">T</span><span style=3D"=
color:#660">&&</span><span style=3D"color:#000"> obj</span><span st=
yle=3D"color:#660">)</span><span style=3D"color:#000"> </span><span style=
=3D"color:#660">{</span><span style=3D"color:#000"><br>=C2=A0 =C2=A0 </span=
><span style=3D"color:#008">return</span><span style=3D"color:#000"> </span=
><span style=3D"color:#008">new</span><span style=3D"color:#000"> T</span><=
span style=3D"color:#660">{</span><span style=3D"color:#000"> std</span><sp=
an style=3D"color:#660">::</span><font color=3D"#000000"><span style=3D"col=
or:#000">forward</span><span style=3D"color:#660"><</span><span style=3D=
"color:#008">decltype</span><span style=3D"color:#660">(</span><span style=
=3D"color:#000">obj</span><span style=3D"color:#660">)></span></font><sp=
an style=3D"color:#660">(</span><span style=3D"color:#000">obj</span><span =
style=3D"color:#660">)};</span><span style=3D"color:#000"><br></span><span =
style=3D"color:#660">}</span><span style=3D"color:#000"><br></span></div></=
code></div><div><br></div>And this works in most cases while only incurring=
a performance hit. However, it breaks down when using objects that either =
can't be copied or moved. Providing overloads of functions that allocat=
e something in a specific provided space can be tedious, too.=C2=A0</div><d=
iv><br></div><div><b>Proposal: </b>putting the new keyword in parethesis be=
fore a function or expression results in the output of that expression bein=
g allocated on the heap, or in the provided buffer.=C2=A0</div><div><br></d=
iv><div>Let's take the function make_tuple as an example:<br></div><div=
><br></div><div><div style=3D"background-color:rgb(250,250,250);border-colo=
r:rgb(187,187,187);border-style:solid;border-width:1px"><code><div><div sty=
le=3D"color:rgb(65,65,65);background-color:rgb(251,251,251);font-family:&qu=
ot;Droid Sans Mono",monospace,monospace,"Droid Sans Fallback"=
;;font-size:14px;line-height:19px;white-space:pre-wrap"><div style=3D"font-=
family:"Droid Sans Mono",monospace,monospace,"Droid Sans Fal=
lback";line-height:19px"><div><span style=3D"color:#05ad97"><span styl=
e=3D"color:#800">#include</span></span><span style=3D"color:#000"> </span><=
span style=3D"color:#3d9ca9"><span style=3D"color:#080"><tuple></span=
></span><span style=3D"color:#000"> </span></div><div><span style=3D"color:=
#d10771"><span style=3D"color:#008">int</span></span><span style=3D"color:#=
000"> </span><span style=3D"color:#8d12ba"><span style=3D"color:#000">main<=
/span></span><span style=3D"color:#660">()</span><span style=3D"color:#000"=
> </span><span style=3D"color:#660">{</span></div><div><span style=3D"color=
:#000"> =C2=A0 =C2=A0</span><span style=3D"color:#05ad97"><span style=3D"co=
lor:#008">using</span></span><span style=3D"color:#000"> std</span><span st=
yle=3D"color:#660">::</span><span style=3D"color:#000">tuple</span><span st=
yle=3D"color:#660">;</span></div><div><span style=3D"color:#000"> =C2=A0 =
=C2=A0</span><span style=3D"color:#05ad97"><span style=3D"color:#008">using=
</span></span><span style=3D"color:#000"> std</span><span style=3D"color:#6=
60">::</span><span style=3D"color:#000">make_tuple</span><span style=3D"col=
or:#660">;</span></div><span style=3D"color:#000"><br></span><div><span sty=
le=3D"color:#000">=C2=A0 =C2=A0 </span><span style=3D"color:#555555;font-st=
yle:italic"><span style=3D"color:#800">/* Allocates tuple normally */</span=
></span></div><div><span style=3D"color:#000"> =C2=A0 =C2=A0tuple</span><sp=
an style=3D"color:#4d4d4d"><span style=3D"color:#660"><</span></span><sp=
an style=3D"color:#d10771"><span style=3D"color:#008">int</span></span><spa=
n style=3D"color:#660">,</span><span style=3D"color:#000"> </span><span sty=
le=3D"color:#d10771"><span style=3D"color:#008">double</span></span><span s=
tyle=3D"color:#4d4d4d"><span style=3D"color:#660">></span></span><span s=
tyle=3D"color:#000"> t1 </span><span style=3D"color:#4d4d4d"><span style=3D=
"color:#660">=3D</span></span><span style=3D"color:#000"> </span><span styl=
e=3D"color:#8d12ba"><span style=3D"color:#000">make_tuple</span></span><spa=
n style=3D"color:#660">(</span><span style=3D"color:#cc5200"><span style=3D=
"color:#066">4</span></span><span style=3D"color:#660">,</span><span style=
=3D"color:#000"> </span><span style=3D"color:#cc5200"><span style=3D"color:=
#066">0.3</span></span><span style=3D"color:#660">);</span></div><span styl=
e=3D"color:#000"><br></span><div><span style=3D"color:#000">=C2=A0 =C2=A0 <=
/span><span style=3D"color:#555555;font-style:italic"><span style=3D"color:=
#800">/*Allocates tuple on heap, returns pointer */</span></span></div><div=
><span style=3D"color:#000"> =C2=A0 =C2=A0tuple</span><span style=3D"color:=
#4d4d4d"><span style=3D"color:#660"><</span></span><span style=3D"color:=
#d10771"><span style=3D"color:#008">int</span></span><span style=3D"color:#=
660">,</span><span style=3D"color:#000"> </span><span style=3D"color:#d1077=
1"><span style=3D"color:#008">double</span></span><span style=3D"color:#4d4=
d4d"><span style=3D"color:#660">>*</span></span><span style=3D"color:#00=
0"> t2 </span><span style=3D"color:#4d4d4d"><span style=3D"color:#660">=3D<=
/span></span><span style=3D"color:#000"> </span><span style=3D"color:#660">=
(</span><span style=3D"color:#05ad97"><span style=3D"color:#008">new</span>=
</span><span style=3D"color:#660">)</span><span style=3D"color:#000"> </spa=
n><span style=3D"color:#8d12ba"><span style=3D"color:#000">make_tuple</span=
></span><span style=3D"color:#660">(</span><span style=3D"color:#cc5200"><s=
pan style=3D"color:#066">4</span></span><span style=3D"color:#660">,</span>=
<span style=3D"color:#000"> </span><span style=3D"color:#cc5200"><span styl=
e=3D"color:#066">0.3</span></span><span style=3D"color:#660">);</span><span=
style=3D"color:#000"> </span></div><span style=3D"color:#000"><br></span><=
div><span style=3D"color:#000">=C2=A0 =C2=A0 </span><span style=3D"color:#d=
10771"><span style=3D"color:#008">char</span></span><span style=3D"color:#0=
00"> buff</span><span style=3D"color:#660">[</span><span style=3D"color:#cc=
5200"><span style=3D"color:#066">100</span></span><span style=3D"color:#660=
">];</span></div><div><span style=3D"color:#000"> =C2=A0 =C2=A0</span></div=
><div><span style=3D"color:#000"> =C2=A0 =C2=A0</span><span style=3D"color:=
#555555;font-style:italic"><span style=3D"color:#800">/* Allocates tuple in=
buff, returns pointer */</span></span></div><div><span style=3D"color:#000=
"> =C2=A0 =C2=A0tuple</span><span style=3D"color:#4d4d4d"><span style=3D"co=
lor:#660"><</span></span><span style=3D"color:#d10771"><span style=3D"co=
lor:#008">int</span></span><span style=3D"color:#660">,</span><span style=
=3D"color:#000"> </span><span style=3D"color:#d10771"><span style=3D"color:=
#008">double</span></span><span style=3D"color:#4d4d4d"><span style=3D"colo=
r:#660">>*</span></span><span style=3D"color:#000"> t3 </span><span styl=
e=3D"color:#4d4d4d"><span style=3D"color:#660">=3D</span></span><span style=
=3D"color:#000"> </span><span style=3D"color:#660">(</span><span style=3D"c=
olor:#8d12ba"><span style=3D"color:#008">new</span></span><span style=3D"co=
lor:#660">(</span><span style=3D"color:#000">buff</span><span style=3D"colo=
r:#660">))</span><span style=3D"color:#000"> </span><span style=3D"color:#8=
d12ba"><span style=3D"color:#000">make_tuple</span></span><span style=3D"co=
lor:#660">(</span><span style=3D"color:#cc5200"><span style=3D"color:#066">=
4</span></span><span style=3D"color:#660">,</span><span style=3D"color:#000=
"> </span><span style=3D"color:#cc5200"><span style=3D"color:#066">0.3</spa=
n></span><span style=3D"color:#660">);</span></div><div><span style=3D"colo=
r:#660">}</span></div><span style=3D"color:#000"><br></span></div></div></d=
iv></code></div><br>if a function returns a reference, it's a compiler =
error to use this construct, and if the function returns a pointer, then th=
is construct returns a pointer to that pointer.=C2=A0</div><div><br></div><=
div><br></div></div></blockquote></div></div>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-=
4163-bb6d-f9cee0fa190b%40isocpp.org</a>.<br>
</blockquote></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOfiQqnyH1r5e5QEKEgeSfa0pg3LbcVDb-UR=
GLgGLap2f%2BJ68A%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOfiQqnyH1r5e5=
QEKEgeSfa0pg3LbcVDb-URGLgGLap2f%2BJ68A%40mail.gmail.com</a>.<br />
--00000000000045748f0578dc2896--
.
Author: mihailnajdenov@gmail.com
Date: Tue, 23 Oct 2018 00:16:18 -0700 (PDT)
Raw View
------=_Part_4882_74888822.1540278979047
Content-Type: multipart/alternative;
boundary="----=_Part_4883_1926723071.1540278979048"
------=_Part_4883_1926723071.1540278979048
Content-Type: text/plain; charset="UTF-8"
On Tuesday, October 23, 2018 at 5:30:52 AM UTC+3, Richard Smith wrote:
>
> On Mon, 22 Oct 2018 at 01:23, <mihailn...@gmail.com <javascript:>> wrote:
>
>> You must give better motivation.
>> If you want to use a function that returns an object and have that object
>> new-ed without copy/move, then you should explain what is stopping you
>> creating the returned object via the new expression in the first place,
>> especially now with template deduction guide.
>> If you want a copy/move of the object, returned by the function you can
>> do this today using new auto(create_object());
>>
>
> If create_object() returns by value (as make_tuple does, for instance),
> this does not perform a copy or move. Rather, it constructs directly into
> the allocated storage. That is, we already have the feature that is being
> requested here: just use 'new'.
>
Great to hear! It didn't know the new RVO rules work here as well as it is
not so obvious - we tend to think this is stack-only. Very interesting...
I might as well update cppreference to note that it works here as well.
>
> My guess is you want the former, but some better examples would be nice.
>>
>>
>> On Monday, October 22, 2018 at 7:43:42 AM UTC+3, sunsetburn...@gmail.com
>> wrote:
>>>
>>> We could write a function to take something allocated on the stack and
>>> return a copy of it on the heap:
>>>
>>> template<class T> T* as_new(T&& obj) {
>>> return new T{ std::forward<decltype(obj)>(obj)};
>>> }
>>>
>>> And this works in most cases while only incurring a performance hit.
>>> However, it breaks down when using objects that either can't be copied or
>>> moved. Providing overloads of functions that allocate something in a
>>> specific provided space can be tedious, too.
>>>
>>> *Proposal: *putting the new keyword in parethesis before a function or
>>> expression results in the output of that expression being allocated on the
>>> heap, or in the provided buffer.
>>>
>>> Let's take the function make_tuple as an example:
>>>
>>> #include <tuple>
>>> int main() {
>>> using std::tuple;
>>> using std::make_tuple;
>>>
>>> /* Allocates tuple normally */
>>> tuple<int, double> t1 = make_tuple(4, 0.3);
>>>
>>> /*Allocates tuple on heap, returns pointer */
>>> tuple<int, double>* t2 = (new) make_tuple(4, 0.3);
>>>
>>> char buff[100];
>>>
>>> /* Allocates tuple in buff, returns pointer */
>>> tuple<int, double>* t3 = (new(buff)) make_tuple(4, 0.3);
>>> }
>>>
>>>
>>> if a function returns a reference, it's a compiler error to use this
>>> construct, and if the function returns a pointer, then this construct
>>> returns a pointer to that pointer.
>>>
>>>
>>> --
>> You received this message because you are subscribed to the Google Groups
>> "ISO C++ Standard - Future Proposals" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to std-proposal...@isocpp.org <javascript:>.
>> To post to this group, send email to std-pr...@isocpp.org <javascript:>.
>> To view this discussion on the web visit
>> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40isocpp.org
>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40isocpp.org?utm_medium=email&utm_source=footer>
>> .
>>
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/bdbf2214-87c0-4d14-8831-c6ffd5da2eba%40isocpp.org.
------=_Part_4883_1926723071.1540278979048
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Tuesday, October 23, 2018 at 5:30:52 AM UTC+3, =
Richard Smith wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;ma=
rgin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=
=3D"ltr"><div class=3D"gmail_quote"><div dir=3D"ltr">On Mon, 22 Oct 2018 at=
01:23, <<a href=3D"javascript:" target=3D"_blank" gdf-obfuscated-mailto=
=3D"YaEZXMU5CgAJ" rel=3D"nofollow" onmousedown=3D"this.href=3D'javascri=
pt:';return true;" onclick=3D"this.href=3D'javascript:';return =
true;">mihailn...@gmail.com</a>> wrote:<br></div><blockquote class=3D"gm=
ail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-le=
ft:1ex"><div dir=3D"ltr">You must give better motivation.=C2=A0<div>If you =
want to use a function that returns an object and have that object new-ed w=
ithout copy/move, then you should explain what is stopping you creating the=
returned object via the new expression in the first place, especially now =
with template deduction guide.</div><div>If you want a copy/move of the obj=
ect, returned by the function you can do this today using <font face=3D"cou=
rier new, monospace">new auto(create_object());</font></div></div></blockqu=
ote><div><br></div><div>If create_object() returns by value (as make_tuple =
does, for instance), this does not perform a copy or move. Rather, it const=
ructs directly into the allocated storage. That is, we already have the fea=
ture that is being requested here: just use 'new'.</div></div></div=
></blockquote><div><br></div><div>Great to hear! It didn't know the new=
RVO rules work here as well as it is not so obvious - we tend to think thi=
s is stack-only. Very interesting...=C2=A0</div><div>I might as well update=
cppreference to note that it works here as well.</div><div>=C2=A0</div><bl=
ockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border=
-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gm=
ail_quote"><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin=
:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><=
div>My guess is you want the former, but some better examples would be nice=
..</div><div><br><br>On Monday, October 22, 2018 at 7:43:42 AM UTC+3, <a>sun=
setburn...@gmail.com</a> wrote:<blockquote class=3D"gmail_quote" style=3D"m=
argin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div=
dir=3D"ltr">We could write a function to take something allocated on the s=
tack and return a copy of it on the heap:<div><br></div><div><div style=3D"=
background-color:rgb(250,250,250);border-color:rgb(187,187,187);border-styl=
e:solid;border-width:1px"><code><div><span style=3D"color:#008">template</s=
pan><span style=3D"color:#660"><</span><span style=3D"color:#008">class<=
/span><span style=3D"color:#000"> T</span><span style=3D"color:#660">></=
span><span style=3D"color:#000"> T</span><span style=3D"color:#660">*</span=
><span style=3D"color:#000"> as_new</span><span style=3D"color:#660">(</spa=
n><span style=3D"color:#000">T</span><span style=3D"color:#660">&&<=
/span><span style=3D"color:#000"> obj</span><span style=3D"color:#660">)</s=
pan><span style=3D"color:#000"> </span><span style=3D"color:#660">{</span><=
span style=3D"color:#000"><br>=C2=A0 =C2=A0 </span><span style=3D"color:#00=
8">return</span><span style=3D"color:#000"> </span><span style=3D"color:#00=
8">new</span><span style=3D"color:#000"> T</span><span style=3D"color:#660"=
>{</span><span style=3D"color:#000"> std</span><span style=3D"color:#660">:=
:</span><font color=3D"#000000"><span style=3D"color:#000">forward</span><s=
pan style=3D"color:#660"><</span><span style=3D"color:#008">decltype</sp=
an><span style=3D"color:#660">(</span><span style=3D"color:#000">obj</span>=
<span style=3D"color:#660">)></span></font><span style=3D"color:#660">(<=
/span><span style=3D"color:#000">ob<wbr>j</span><span style=3D"color:#660">=
)};</span><span style=3D"color:#000"><br></span><span style=3D"color:#660">=
}</span><span style=3D"color:#000"><br></span></div></code></div><div><br><=
/div>And this works in most cases while only incurring a performance hit. H=
owever, it breaks down when using objects that either can't be copied o=
r moved. Providing overloads of functions that allocate something in a spec=
ific provided space can be tedious, too.=C2=A0</div><div><br></div><div><b>=
Proposal: </b>putting the new keyword in parethesis before a function or ex=
pression results in the output of that expression being allocated on the he=
ap, or in the provided buffer.=C2=A0</div><div><br></div><div>Let's tak=
e the function make_tuple as an example:<br></div><div><br></div><div><div =
style=3D"background-color:rgb(250,250,250);border-color:rgb(187,187,187);bo=
rder-style:solid;border-width:1px"><code><div><div style=3D"color:rgb(65,65=
,65);background-color:rgb(251,251,251);font-family:"Droid Sans Mono&qu=
ot;,monospace,monospace,"Droid Sans Fallback";font-size:14px;line=
-height:19px;white-space:pre-wrap"><div style=3D"font-family:"Droid Sa=
ns Mono",monospace,monospace,"Droid Sans Fallback";line-heig=
ht:19px"><div><span style=3D"color:#05ad97"><span style=3D"color:#800">#inc=
lude</span></span><span style=3D"color:#000"> </span><span style=3D"color:#=
3d9ca9"><span style=3D"color:#080"><tuple></span></span><span style=
=3D"color:#000"> </span></div><div><span style=3D"color:#d10771"><span styl=
e=3D"color:#008">int</span></span><span style=3D"color:#000"> </span><span =
style=3D"color:#8d12ba"><span style=3D"color:#000">main</span></span><span =
style=3D"color:#660">()</span><span style=3D"color:#000"> </span><span styl=
e=3D"color:#660">{</span></div><div><span style=3D"color:#000"> =C2=A0 =C2=
=A0</span><span style=3D"color:#05ad97"><span style=3D"color:#008">using</s=
pan></span><span style=3D"color:#000"> std</span><span style=3D"color:#660"=
>::</span><span style=3D"color:#000">tuple</span><span style=3D"color:#660"=
>;</span></div><div><span style=3D"color:#000"> =C2=A0 =C2=A0</span><span s=
tyle=3D"color:#05ad97"><span style=3D"color:#008">using</span></span><span =
style=3D"color:#000"> std</span><span style=3D"color:#660">::</span><span s=
tyle=3D"color:#000">make_tuple</span><span style=3D"color:#660">;</span></d=
iv><span style=3D"color:#000"><br></span><div><span style=3D"color:#000">=
=C2=A0 =C2=A0 </span><span style=3D"color:#555555;font-style:italic"><span =
style=3D"color:#800">/* Allocates tuple normally */</span></span></div><div=
><span style=3D"color:#000"> =C2=A0 =C2=A0tuple</span><span style=3D"color:=
#4d4d4d"><span style=3D"color:#660"><</span></span><span style=3D"color:=
#d10771"><span style=3D"color:#008">int</span></span><span style=3D"color:#=
660">,</span><span style=3D"color:#000"> </span><span style=3D"color:#d1077=
1"><span style=3D"color:#008">double</span></span><span style=3D"color:#4d4=
d4d"><span style=3D"color:#660">></span></span><span style=3D"color:#000=
"> t1 </span><span style=3D"color:#4d4d4d"><span style=3D"color:#660">=3D</=
span></span><span style=3D"color:#000"> </span><span style=3D"color:#8d12ba=
"><span style=3D"color:#000">make_tuple</span></span><span style=3D"color:#=
660">(</span><span style=3D"color:#cc5200"><span style=3D"color:#066">4</sp=
an></span><span style=3D"color:#660">,</span><span style=3D"color:#000"> </=
span><span style=3D"color:#cc5200"><span style=3D"color:#066">0.3</span></s=
pan><span style=3D"color:#660">);</span></div><span style=3D"color:#000"><b=
r></span><div><span style=3D"color:#000">=C2=A0 =C2=A0 </span><span style=
=3D"color:#555555;font-style:italic"><span style=3D"color:#800">/*Allocates=
tuple on heap, returns pointer */</span></span></div><div><span style=3D"c=
olor:#000"> =C2=A0 =C2=A0tuple</span><span style=3D"color:#4d4d4d"><span st=
yle=3D"color:#660"><</span></span><span style=3D"color:#d10771"><span st=
yle=3D"color:#008">int</span></span><span style=3D"color:#660">,</span><spa=
n style=3D"color:#000"> </span><span style=3D"color:#d10771"><span style=3D=
"color:#008">double</span></span><span style=3D"color:#4d4d4d"><span style=
=3D"color:#660">>*</span></span><span style=3D"color:#000"> t2 </span><s=
pan style=3D"color:#4d4d4d"><span style=3D"color:#660">=3D</span></span><sp=
an style=3D"color:#000"> </span><span style=3D"color:#660">(</span><span st=
yle=3D"color:#05ad97"><span style=3D"color:#008">new</span></span><span sty=
le=3D"color:#660">)</span><span style=3D"color:#000"> </span><span style=3D=
"color:#8d12ba"><span style=3D"color:#000">make_tuple</span></span><span st=
yle=3D"color:#660">(</span><span style=3D"color:#cc5200"><span style=3D"col=
or:#066">4</span></span><span style=3D"color:#660">,</span><span style=3D"c=
olor:#000"> </span><span style=3D"color:#cc5200"><span style=3D"color:#066"=
>0.3</span></span><span style=3D"color:#660">);</span><span style=3D"color:=
#000"> </span></div><span style=3D"color:#000"><br></span><div><span style=
=3D"color:#000">=C2=A0 =C2=A0 </span><span style=3D"color:#d10771"><span st=
yle=3D"color:#008">char</span></span><span style=3D"color:#000"> buff</span=
><span style=3D"color:#660">[</span><span style=3D"color:#cc5200"><span sty=
le=3D"color:#066">100</span></span><span style=3D"color:#660">];</span></di=
v><div><span style=3D"color:#000"> =C2=A0 =C2=A0</span></div><div><span sty=
le=3D"color:#000"> =C2=A0 =C2=A0</span><span style=3D"color:#555555;font-st=
yle:italic"><span style=3D"color:#800">/* Allocates tuple in buff, returns =
pointer */</span></span></div><div><span style=3D"color:#000"> =C2=A0 =C2=
=A0tuple</span><span style=3D"color:#4d4d4d"><span style=3D"color:#660"><=
;</span></span><span style=3D"color:#d10771"><span style=3D"color:#008">int=
</span></span><span style=3D"color:#660">,</span><span style=3D"color:#000"=
> </span><span style=3D"color:#d10771"><span style=3D"color:#008">double</s=
pan></span><span style=3D"color:#4d4d4d"><span style=3D"color:#660">>*</=
span></span><span style=3D"color:#000"> t3 </span><span style=3D"color:#4d4=
d4d"><span style=3D"color:#660">=3D</span></span><span style=3D"color:#000"=
> </span><span style=3D"color:#660">(</span><span style=3D"color:#8d12ba"><=
span style=3D"color:#008">new</span></span><span style=3D"color:#660">(</sp=
an><span style=3D"color:#000">buff</span><span style=3D"color:#660">))</spa=
n><span style=3D"color:#000"> </span><span style=3D"color:#8d12ba"><span st=
yle=3D"color:#000">make_tuple</span></span><span style=3D"color:#660">(</sp=
an><span style=3D"color:#cc5200"><span style=3D"color:#066">4</span></span>=
<span style=3D"color:#660">,</span><span style=3D"color:#000"> </span><span=
style=3D"color:#cc5200"><span style=3D"color:#066">0.3</span></span><span =
style=3D"color:#660">);</span></div><div><span style=3D"color:#660">}</span=
></div><span style=3D"color:#000"><br></span></div></div></div></code></div=
><br>if a function returns a reference, it's a compiler error to use th=
is construct, and if the function returns a pointer, then this construct re=
turns a pointer to that pointer.=C2=A0</div><div><br></div><div><br></div><=
/div></blockquote></div></div>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"javascript:" target=3D"_blank" gdf-obfuscated-mailto=3D"=
YaEZXMU5CgAJ" rel=3D"nofollow" onmousedown=3D"this.href=3D'javascript:&=
#39;;return true;" onclick=3D"this.href=3D'javascript:';return true=
;">std-proposal...@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"javascript:" target=3D"_bla=
nk" gdf-obfuscated-mailto=3D"YaEZXMU5CgAJ" rel=3D"nofollow" onmousedown=3D"=
this.href=3D'javascript:';return true;" onclick=3D"this.href=3D'=
;javascript:';return true;">std-pr...@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank" =
rel=3D"nofollow" onmousedown=3D"this.href=3D'https://groups.google.com/=
a/isocpp.org/d/msgid/std-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40i=
socpp.org?utm_medium\x3demail\x26utm_source\x3dfooter';return true;" on=
click=3D"this.href=3D'https://groups.google.com/a/isocpp.org/d/msgid/st=
d-proposals/c5e8d685-d72c-4163-bb6d-f9cee0fa190b%40isocpp.org?utm_medium\x3=
demail\x26utm_source\x3dfooter';return true;">https://groups.google.com=
/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/c5e8d685-d72c-4163-<wbr>bb6d-=
f9cee0fa190b%40isocpp.org</a><wbr>.<br>
</blockquote></div></div>
</blockquote></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/bdbf2214-87c0-4d14-8831-c6ffd5da2eba%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/bdbf2214-87c0-4d14-8831-c6ffd5da2eba=
%40isocpp.org</a>.<br />
------=_Part_4883_1926723071.1540278979048--
------=_Part_4882_74888822.1540278979047--
.