www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Difference between static and non-static opAssign?

reply =?ISO-8859-1?Q?Alex_R=F8nne_Petersen?= <xtzgzorex gmail.com> writes:
Hi,

Consider this:

 struct S
 {
     static S opAssign(int rhs)
     {
         return S();
     }
 }

 void main()
 {
     S s;
     s = 1;
 }

And:
 struct S
 {
     S opAssign(int rhs)
     {
         return S();
     }
 }

 void main()
 {
     S s;
     s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed? - Alex
Sep 01 2011
next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Thu, 01 Sep 2011 15:08:29 -0400, Alex R=C3=B8nne Petersen  =

<xtzgzorex gmail.com> wrote:

 Hi,

 Consider this:

 struct S
 {
     static S opAssign(int rhs)
     {
         return S();
     }
 }

 void main()
 {
     S s;
     s =3D 1;
 }

And:
 struct S
 {
     S opAssign(int rhs)
     {
         return S();
     }
 }

 void main()
 {
     S s;
     s =3D 1;
 }

Both will compile. I don't get it. I can understand it in the case of =

 the static opAssign, but with the non-static one, what does 'this' ref=

 to inside opAssign? And why are both seemingly allowed?

s =3D 1 is rewritten as s.opAssign(1). So in the non-static version, 't= his' = refers to the struct you called the function with (in your example, s). so: struct S { int x; S opAssign(int rhs) { x =3D rhs; return this; } } void main() { S s; s =3D 5; assert(s.x =3D=3D 5); } Since you are allowed to call static member functions, s.opAssign(1) for= = the static one succeeds, but some of us are pushing to make this invalid= . = It makes things very confusing when you call static functions, but it = looks like you are calling non-static member functions. -Steve
Sep 01 2011
parent reply =?UTF-8?B?QWxleCBSw7hubmUgUGV0ZXJzZW4=?= <xtzgzorex gmail.com> writes:
On 01-09-2011 21:13, Steven Schveighoffer wrote:
 On Thu, 01 Sep 2011 15:08:29 -0400, Alex Rønne Petersen
 <xtzgzorex gmail.com> wrote:

 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed?

s = 1 is rewritten as s.opAssign(1). So in the non-static version, 'this' refers to the struct you called the function with (in your example, s). so: struct S { int x; S opAssign(int rhs) { x = rhs; return this; } } void main() { S s; s = 5; assert(s.x == 5); } Since you are allowed to call static member functions, s.opAssign(1) for the static one succeeds, but some of us are pushing to make this invalid. It makes things very confusing when you call static functions, but it looks like you are calling non-static member functions. -Steve

So that's to say x = 5; with a static opAssign would actually just... do nothing? - Alex
Sep 01 2011
next sibling parent reply Timon Gehr <timon.gehr gmx.ch> writes:
On 09/01/2011 09:18 PM, Alex Rønne Petersen wrote:
 On 01-09-2011 21:13, Steven Schveighoffer wrote:
 On Thu, 01 Sep 2011 15:08:29 -0400, Alex Rønne Petersen
 <xtzgzorex gmail.com> wrote:

 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed?

s = 1 is rewritten as s.opAssign(1). So in the non-static version, 'this' refers to the struct you called the function with (in your example, s). so: struct S { int x; S opAssign(int rhs) { x = rhs; return this; } } void main() { S s; s = 5; assert(s.x == 5); } Since you are allowed to call static member functions, s.opAssign(1) for the static one succeeds, but some of us are pushing to make this invalid. It makes things very confusing when you call static functions, but it looks like you are calling non-static member functions. -Steve

So that's to say x = 5; with a static opAssign would actually just... do nothing? - Alex

It will execute the body of static opAssign which could contain arbitrary code.
Sep 01 2011
parent =?UTF-8?B?QWxleCBSw7hubmUgUGV0ZXJzZW4=?= <xtzgzorex gmail.com> writes:
On 01-09-2011 21:26, Timon Gehr wrote:
 On 09/01/2011 09:18 PM, Alex Rønne Petersen wrote:
 On 01-09-2011 21:13, Steven Schveighoffer wrote:
 On Thu, 01 Sep 2011 15:08:29 -0400, Alex Rønne Petersen
 <xtzgzorex gmail.com> wrote:

 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed?

s = 1 is rewritten as s.opAssign(1). So in the non-static version, 'this' refers to the struct you called the function with (in your example, s). so: struct S { int x; S opAssign(int rhs) { x = rhs; return this; } } void main() { S s; s = 5; assert(s.x == 5); } Since you are allowed to call static member functions, s.opAssign(1) for the static one succeeds, but some of us are pushing to make this invalid. It makes things very confusing when you call static functions, but it looks like you are calling non-static member functions. -Steve

So that's to say x = 5; with a static opAssign would actually just... do nothing? - Alex

It will execute the body of static opAssign which could contain arbitrary code.

Oh right. Hadn't thought of that. It still seems very obscure, though. - Alex
Sep 01 2011
prev sibling parent =?UTF-8?B?QWxleCBSw7hubmUgUGV0ZXJzZW4=?= <xtzgzorex gmail.com> writes:
On 01-09-2011 21:29, Steven Schveighoffer wrote:
 On Thu, 01 Sep 2011 15:18:58 -0400, Alex Rønne Petersen
 <xtzgzorex gmail.com> wrote:

 On 01-09-2011 21:13, Steven Schveighoffer wrote:

 Since you are allowed to call static member functions, s.opAssign(1) for
 the static one succeeds, but some of us are pushing to make this
 invalid. It makes things very confusing when you call static functions,
 but it looks like you are calling non-static member functions.

do nothing?

Well, it would do nothing to x, since x isn't passed to the function (it could possibly affect some static member). Which is why I feel it's a far more confusing feature than it is worth. However, there are some legitimate reasons to have a static function be callable using an instance, which have to do with generic programming. I recently created an enhancement request on this: http://d.puremagic.com/issues/show_bug.cgi?id=6579 -Steve

I agree, it is confusing. Many other languages get by just fine without static calls on instances, so I'm sure D can too... - Alex
Sep 01 2011
prev sibling next sibling parent Timon Gehr <timon.gehr gmx.ch> writes:
On 09/01/2011 09:08 PM, Alex Rnne Petersen wrote:
 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed? - Alex

s = 1; is rewritten to s.opAssign(1); Inside non-static opAssign, therefore 'this' will refer to s.
Sep 01 2011
prev sibling next sibling parent reply =?ISO-8859-1?Q?Alex_R=F8nne_Petersen?= <xtzgzorex gmail.com> writes:
On 01-09-2011 21:08, Alex Rnne Petersen wrote:
 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed? - Alex

Somewhat related question: should opAssign return void or return an actual value? Does it matter? If x = y is rewritten to x.opAssign(y), I assume it doesn't... - Alex
Sep 01 2011
parent reply Timon Gehr <timon.gehr gmx.ch> writes:
On 09/01/2011 09:25 PM, Alex Rnne Petersen wrote:
 On 01-09-2011 21:08, Alex Rnne Petersen wrote:
 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed? - Alex

Somewhat related question: should opAssign return void or return an actual value? Does it matter? If x = y is rewritten to x.opAssign(y), I assume it doesn't... - Alex

It does matter for eg multiple assignment: a = b = c; // return void and this will not work anymore
Sep 01 2011
parent =?ISO-8859-1?Q?Alex_R=F8nne_Petersen?= <xtzgzorex gmail.com> writes:
On 01-09-2011 21:27, Timon Gehr wrote:
 On 09/01/2011 09:25 PM, Alex Rnne Petersen wrote:
 On 01-09-2011 21:08, Alex Rnne Petersen wrote:
 Hi,

 Consider this:

 struct S
 {
 static S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

And:
 struct S
 {
 S opAssign(int rhs)
 {
 return S();
 }
 }

 void main()
 {
 S s;
 s = 1;
 }

Both will compile. I don't get it. I can understand it in the case of the static opAssign, but with the non-static one, what does 'this' refer to inside opAssign? And why are both seemingly allowed? - Alex

Somewhat related question: should opAssign return void or return an actual value? Does it matter? If x = y is rewritten to x.opAssign(y), I assume it doesn't... - Alex

It does matter for eg multiple assignment: a = b = c; // return void and this will not work anymore

Ah, that makes sense! Thanks. - Alex
Sep 01 2011
prev sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Thu, 01 Sep 2011 15:18:58 -0400, Alex R=C3=B8nne Petersen  =

<xtzgzorex gmail.com> wrote:

 On 01-09-2011 21:13, Steven Schveighoffer wrote:

 Since you are allowed to call static member functions, s.opAssign(1) =


 the static one succeeds, but some of us are pushing to make this
 invalid. It makes things very confusing when you call static function=


 but it looks like you are calling non-static member functions.


 nothing?

Well, it would do nothing to x, since x isn't passed to the function (it= = could possibly affect some static member). Which is why I feel it's a f= ar = more confusing feature than it is worth. However, there are some legitimate reasons to have a static function be = = callable using an instance, which have to do with generic programming. I recently created an enhancement request on this: http://d.puremagic.com/issues/show_bug.cgi?id=3D6579 -Steve
Sep 01 2011