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.

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

"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

"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

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.

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.

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.