Thread overview | ||||||||
---|---|---|---|---|---|---|---|---|
|
August 06, 2010 ref is pointer sugar? | ||||
---|---|---|---|---|
| ||||
Are these equivalent? S s;//struct void f(ref S s){s.x++;} f(s); void f2(S* s){(*s).x++;} f2(&s); If so, why is it stated that ref is very rarely used? It looks like something I would use a lot with structures. |
August 06, 2010 Re: ref is pointer sugar? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Pluto | On Fri, 06 Aug 2010 08:51:31 -0400, Pluto <pluto@planets.not> wrote: > Are these equivalent? > > S s;//struct > > void f(ref S s){s.x++;} > f(s); > > void f2(S* s){(*s).x++;} > f2(&s); They are pretty much equivalent. I think the code generated actually will be exactly the same. However, the compiler treats ref differently than pointers. For example, ref is allowed in the safe subset of D, and pointers are not. Note that you do not need to dereference pointers to access their pointed-to members. i.e.: void f2(S* s){s.x++;} > > If so, why is it stated that ref is very rarely used? > It looks like something I would use a lot with structures. What? Where does it say that? That's very wrong, ref is used everywhere. If not explicitly, at least every struct member function passes 'this' by ref. -Steve |
August 06, 2010 Re: ref is pointer sugar? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Steven Schveighoffer | == Quote from Steven Schveighoffer (schveiguy@yahoo.com)'s article
> On Fri, 06 Aug 2010 08:51:31 -0400, Pluto <pluto@planets.not> wrote:
> > Are these equivalent?
> >
> > S s;//struct
> >
> > void f(ref S s){s.x++;}
> > f(s);
> >
> > void f2(S* s){(*s).x++;}
> > f2(&s);
> They are pretty much equivalent. I think the code generated actually will
> be exactly the same. However, the compiler treats ref differently than
> pointers. For example, ref is allowed in the safe subset of D, and
> pointers are not.
> Note that you do not need to dereference pointers to access their
> pointed-to members. i.e.:
> void f2(S* s){s.x++;}
> >
> > If so, why is it stated that ref is very rarely used?
> > It looks like something I would use a lot with structures.
> What? Where does it say that? That's very wrong, ref is used
> everywhere. If not explicitly, at least every struct member function
> passes 'this' by ref.
> -Steve
I read it on the function page of D1.
"out is rare enough, and ref even rarer, to attach the keywords to them and leave
in as the default. "
I would think out to be more rare then ref.
|
August 06, 2010 Re: ref is pointer sugar? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Steven Schveighoffer | == Quote from Steven Schveighoffer (schveiguy@yahoo.com)'s article
> On Fri, 06 Aug 2010 08:51:31 -0400, Pluto <pluto@planets.not> wrote:
> > Are these equivalent?
> >
> > S s;//struct
> >
> > void f(ref S s){s.x++;}
> > f(s);
> >
> > void f2(S* s){(*s).x++;}
> > f2(&s);
> They are pretty much equivalent. I think the code generated actually will
> be exactly the same. However, the compiler treats ref differently than
> pointers. For example, ref is allowed in the safe subset of D, and
> pointers are not.
> Note that you do not need to dereference pointers to access their
> pointed-to members. i.e.:
> void f2(S* s){s.x++;}
Where is this in the spec? I can't find it. Still used to ->
|
August 06, 2010 Re: ref is pointer sugar? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Pluto | On 2010-08-06 15:33, Pluto wrote: > == Quote from Steven Schveighoffer (schveiguy@yahoo.com)'s article >> On Fri, 06 Aug 2010 08:51:31 -0400, Pluto<pluto@planets.not> wrote: >>> Are these equivalent? >>> >>> S s;//struct >>> >>> void f(ref S s){s.x++;} >>> f(s); >>> >>> void f2(S* s){(*s).x++;} >>> f2(&s); >> They are pretty much equivalent. I think the code generated actually will >> be exactly the same. However, the compiler treats ref differently than >> pointers. For example, ref is allowed in the safe subset of D, and >> pointers are not. >> Note that you do not need to dereference pointers to access their >> pointed-to members. i.e.: >> void f2(S* s){s.x++;} > > Where is this in the spec? I can't find it. Still used to -> http://www.digitalmars.com/d/1.0/class.html section "Fields". -- /Jacob Carlborg |
August 06, 2010 Re: ref is pointer sugar? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jacob Carlborg | == Quote from Jacob Carlborg (doob@me.com)'s article
> On 2010-08-06 15:33, Pluto wrote:
> > == Quote from Steven Schveighoffer (schveiguy@yahoo.com)'s article
> >> On Fri, 06 Aug 2010 08:51:31 -0400, Pluto<pluto@planets.not> wrote:
> >>> Are these equivalent?
> >>>
> >>> S s;//struct
> >>>
> >>> void f(ref S s){s.x++;}
> >>> f(s);
> >>>
> >>> void f2(S* s){(*s).x++;}
> >>> f2(&s);
> >> They are pretty much equivalent. I think the code generated actually will
> >> be exactly the same. However, the compiler treats ref differently than
> >> pointers. For example, ref is allowed in the safe subset of D, and
> >> pointers are not.
> >> Note that you do not need to dereference pointers to access their
> >> pointed-to members. i.e.:
> >> void f2(S* s){s.x++;}
> >
> > Where is this in the spec? I can't find it. Still used to ->
> http://www.digitalmars.com/d/1.0/class.html section "Fields".
And this is more generally also applicable to dereferencing pointers. Isn't that showing a bit of a gap in the specs? (bug report?)
|
Copyright © 1999-2021 by the D Language Foundation