www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - ref is pointer sugar?

reply Pluto <pluto planets.not> writes:
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.
Aug 06 2010
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
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
Aug 06 2010
next sibling parent Pluto <pluto planets.not> writes:
== 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);



 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.



 everywhere.  If not explicitly, at least every struct member function
 passes 'this' by ref.
 -Steve



"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.
Aug 06 2010
prev sibling parent reply Pluto <pluto planets.not> writes:
== 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);



 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 ->
Aug 06 2010
parent reply Jacob Carlborg <doob me.com> writes:
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);



 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
Aug 06 2010
parent Pluto <pluto planets.not> writes:
== 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);



 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 ->






Isn't that showing a bit of a gap in the specs? (bug report?)
Aug 06 2010