View mode: basic / threaded / horizontal-split · Log in · Help
March 10, 2004
Neat trick: Constructor for struct or union
I've just noticed that there was a thread on struct constructors I 
overlooked about a month ago, but it doesn't seem to be all there when I 
look now.

Well, I discovered this little trick last night and I like it.

You can do something like

struct Qwert {
	int asdfg;

	static Qwert opCall(int a) {
		Qwert hjkl;
		hjkl.asdfg = a;
		return hjkl;
	}
}

Then you effectively have a constructor for the struct, and you can call 
it just like one syntax of C++ constructor:

	Qwert zxcvb = Qwert(42);
	nm(Qwert(105));

So you can effectively do what you can do with class constructors, 
without the overhead of instantiating a class.  It's a bit like defining 
a syntax for a literal of struct type, making it possible to assign 
straight to one where you can't use the static initialiser syntax.

And unlike C++ constructors, defining one doesn't automatically undefine 
the static initialiser syntax, so the programmer still has the 
flexibility of having either available.

Of course you could define a static method with any old name, like the 
old 'factory methods' in some Java classes that are capable of doing 
some of the things constructors aren't (like reusing instances).  My 
idea is basically the same as this, but with the syntactic sugar of 
Qwert(69) rather than Qwert.instance(69).

Stewart.

-- 
My e-mail is valid but not my primary mailbox, aside from its being the 
unfortunate victim of intensive mail-bombing at the moment.  Please keep 
replies on the 'group where everyone may benefit.
March 10, 2004
Re: Neat trick: Constructor for struct or union
Stewart Gordon wrote:
> You can do something like
> 
> struct Qwert {
>     int asdfg;
> 
>     static Qwert opCall(int a) {
>         Qwert hjkl;
>         hjkl.asdfg = a;
>         return hjkl;
>     }
> }
> 
> Then you effectively have a constructor for the struct, and you can call 
> it just like one syntax of C++ constructor:
> 
>     Qwert zxcvb = Qwert(42);
>     nm(Qwert(105));

Slick!

 -- andy
March 11, 2004
Re: Neat trick: Constructor for struct or union
"Stewart Gordon" <smjg_1998@yahoo.com> wrote in message
news:c2nllg$1nog$1@digitaldaemon.com
| ...
| Then you effectively have a constructor for the struct,
| and you can call it just like one syntax of C++
| constructor:
|
| Qwert zxcvb = Qwert(42);
| nm(Qwert(105));
| ...
|
| Stewart.
|

Not that you'd need it, but if you want C++ syntax, you can do that for
classes too.

-----------------------
Carlos Santander Bernal
March 11, 2004
Re: Neat trick: Constructor for struct or union
"Stewart Gordon" <smjg_1998@yahoo.com> wrote in message
news:c2nllg$1nog$1@digitaldaemon.com
| I've just noticed that there was a thread on struct
| constructors I overlooked about a month ago, but it
| doesn't seem to be all there when I look now.
|
| Well, I discovered this little trick last night and I
| like it.
|
| You can do something like
|
| struct Qwert {
| int asdfg;
|
| static Qwert opCall(int a) {
| Qwert hjkl;
| hjkl.asdfg = a;
| return hjkl;
| }
| }
|
| Then you effectively have a constructor for the struct,
| and you can call it just like one syntax of C++
| constructor:
|
| Qwert zxcvb = Qwert(42);
| nm(Qwert(105));
|
| So you can effectively do what you can do with class
| constructors, without the overhead of instantiating a
| class.  It's a bit like defining a syntax for a literal
| of struct type, making it possible to assign straight to
| one where you can't use the static initialiser syntax.
|
| And unlike C++ constructors, defining one doesn't
| automatically undefine the static initialiser syntax, so
| the programmer still has the flexibility of having either
| available.
|
| Of course you could define a static method with any old
| name, like the old 'factory methods' in some Java classes
| that are capable of doing some of the things constructors
| aren't (like reusing instances).  My idea is basically
| the same as this, but with the syntactic sugar of
| Qwert(69) rather than Qwert.instance(69).
|
| Stewart.
|
| --
| My e-mail is valid but not my primary mailbox, aside from
| its being the unfortunate victim of intensive
| mail-bombing at the moment.  Please keep replies on the
| 'group where everyone may benefit.

However, using this doesn't let you properly overload opCall:

import std.c.stdio;
struct A {
   static A opCall(int a) { A r; r.aa=a; return r; }
   void opCall() { printf("a=%d\n",aa); }
   int aa;
}
void main() {
   A a=A(34);
   a(); //<-Error
}

Produces: "Error: expected 1 arguments, not 0".

-----------------------
Carlos Santander Bernal
March 11, 2004
[Bug] Re: Neat trick: Constructor for struct or union
Carlos Santander B. wrote:

<snip>
> import std.c.stdio;
> struct A {
>     static A opCall(int a) { A r; r.aa=a; return r; }
>     void opCall() { printf("a=%d\n",aa); }
>     int aa;
> }
> void main() {
>     A a=A(34);
>     a(); //<-Error
> }
> 
> Produces: "Error: expected 1 arguments, not 0".

Ah, that looks like a compiler bug to me.  Possible diagnoses I can see:

(a) confused by static and non-static methods with same name
(b) operator overloading not fully implemented for structs
(c) confused by multiple versions of opCall with different parameter lists
(d) some linear combination of (a), (b) and (c).

I'll be able to experiment when I get back onto my PC....

Stewart.

-- 
My e-mail is valid but not my primary mailbox, aside from its being the 
unfortunate victim of intensive mail-bombing at the moment.  Please keep 
replies on the 'group where everyone may benefit.
March 11, 2004
Re: Neat trick: Constructor for struct or union
Inspire moment, to be sure.  That's getting written down in my big book 
o' snippets.

-C. Sauls
-Invironz

Stewart Gordon wrote:
> I've just noticed that there was a thread on struct constructors I 
> overlooked about a month ago, but it doesn't seem to be all there when I 
> look now.
> 
> Well, I discovered this little trick last night and I like it.
> 
> You can do something like
> 
> struct Qwert {
>     int asdfg;
> 
>     static Qwert opCall(int a) {
>         Qwert hjkl;
>         hjkl.asdfg = a;
>         return hjkl;
>     }
> }
> 
> Then you effectively have a constructor for the struct, and you can call 
> it just like one syntax of C++ constructor:
> 
>     Qwert zxcvb = Qwert(42);
>     nm(Qwert(105));
> 
> So you can effectively do what you can do with class constructors, 
> without the overhead of instantiating a class.  It's a bit like defining 
> a syntax for a literal of struct type, making it possible to assign 
> straight to one where you can't use the static initialiser syntax.
> 
> And unlike C++ constructors, defining one doesn't automatically undefine 
> the static initialiser syntax, so the programmer still has the 
> flexibility of having either available.
> 
> Of course you could define a static method with any old name, like the 
> old 'factory methods' in some Java classes that are capable of doing 
> some of the things constructors aren't (like reusing instances).  My 
> idea is basically the same as this, but with the syntactic sugar of 
> Qwert(69) rather than Qwert.instance(69).
> 
> Stewart.
>
March 11, 2004
Re: Neat trick: Constructor for struct or union
Snippets are cool. Would you like to publish them?

-eye


C. Sauls schrieb:

> Inspire moment, to be sure.  That's getting written down in my big book 
> o' snippets.
> 
> -C. Sauls
> -Invironz
> 
> Stewart Gordon wrote:
> 
>> I've just noticed that there was a thread on struct constructors I 
>> overlooked about a month ago, but it doesn't seem to be all there when 
>> I look now.
>>
>> Well, I discovered this little trick last night and I like it.
>>
>> You can do something like
>>
>> struct Qwert {
>>     int asdfg;
>>
>>     static Qwert opCall(int a) {
>>         Qwert hjkl;
>>         hjkl.asdfg = a;
>>         return hjkl;
>>     }
>> }
>>
>> Then you effectively have a constructor for the struct, and you can 
>> call it just like one syntax of C++ constructor:
>>
>>     Qwert zxcvb = Qwert(42);
>>     nm(Qwert(105));
>>
>> So you can effectively do what you can do with class constructors, 
>> without the overhead of instantiating a class.  It's a bit like 
>> defining a syntax for a literal of struct type, making it possible to 
>> assign straight to one where you can't use the static initialiser syntax.
>>
>> And unlike C++ constructors, defining one doesn't automatically 
>> undefine the static initialiser syntax, so the programmer still has 
>> the flexibility of having either available.
>>
>> Of course you could define a static method with any old name, like the 
>> old 'factory methods' in some Java classes that are capable of doing 
>> some of the things constructors aren't (like reusing instances).  My 
>> idea is basically the same as this, but with the syntactic sugar of 
>> Qwert(69) rather than Qwert.instance(69).
>>
>> Stewart.
>>
Top | Discussion index | About this forum | D home