On 17/09/12 20:47, Maxim Fomin wrote:
I consider current struct creation one of the confusing parts of the
language (may be the most), due to set of incompatible creation
semantics masked by same syntax, complicated by couple of semi-bugs
(7210, 1310, 4053) and naive default arguments embedding into the
language(3438).
Current creation rules look as follows (http://dpaste.dzfl.pl/a4344ad0):
1) if a struct object declaration has no initializer, its members are
default initialized to either explicit initializer in struct declaration
or type default initializer (note: actually, there are no implicit
struct constructors). If it has void initializer, it contains garbage
2) otherwise, if it has initialization form S() than:
a) if opCall member is present, it is called (must have no arguments)
b) otherwise, initialization proceed according to 1)
3) otherwise, if it has initialization form S(T1 arg1, ...), than:
a) if opCall member is present, it is called (its parameters must be
consistent with arguments)
b) otherwise, if at least one ctor exists, it is called (and again, its
parameters must be consistent with arguments)
c) otherwise, this initialization form is called struct literal and
struct members are initialized to arguments in accordance with their
order in struct declaration
There is also 4) struct static initializers, which have their own
complicated set of rules.
This means that if you have S(), or S(x, y, x) - it is impossible to
know without looking into struct definition what is going on: a function
call (constructor or opCall) or just initialization. If naive default
argument treatment is considered, I may add that there is no sense of
setting default argument to one-argument struct constructor, since
S()-like expression would call something else (3438). By the way, .init
property may be hijacked (good news is that it doesn't affect default
initializer).
Basically, the question is, is it considered to be good, well designed
feature or not. And if not, would it be changed at some time? What was
original design of structures in D?
Struct constructors and struct literals are late additions. opCall was,
I think, a workaround for the lack of struct constructors.
There's a comment in the source code:
***************************************
* This works by transforming a struct initializer into
* a struct literal. In the future, the two should be the
* same thing.
*/
Expression *StructInitializer::toExpression()
That's the only plan I've heard of.
