www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - struct initialization and assignment by field name

reply Bobby Bingham <uhmmmm gmail.com> writes:
I'm just starting out with D, and am wondering about some differences 
with C regarding struct literals. In C99, I can do this:

struct MyStruct {
    int  number;
    char letter;
};

int main() {
    static struct MyStruct foo = { .number = 42, .letter = 'a' };
    struct MyStruct bar = { .number = 42, .letter = 'a' };
    bar = (struct MyStruct) { .number = 42, .letter = 'a' };
    return 0;
}

That is, I can initialize static and non-static struct variables by 
specifying the fields as key-value pairs.  I can also assign a struct 
literal to an already-declared struct variable in the same way.

If we try this in D:

struct MyStruct {
    int  number;
    char letter;
}

int main() {
    static MyStruct foo = { number:42, letter:'a' }; // works
    MyStruct bar = { number:42, letter:'a' };        // works despite [1]
    bar = { number:42, letter:'a' };                 // fails to compile
    return 0;
}

That is, I can do something similar for static struct initializers in D, 
and non-static struct initializers despite this being documented as not 
allowed.

It appears that this form of struct literal really can only be used in 
initializers -- the assignment to a previously declared varaible fails to 
compile.

I'm hoping somebody can shed some light on the rationale for only 
supporting this form of struct literal in initializers. And also why it's 
documented to only work for static initializers -- is this an error in 
the documentation, or is the compiler allowing things it shouldn't?

Thanks,
Bobby

1. http://dlang.org/struct.html
   "The sta­tic ini­tial­izer syn­tax can also be used to ini­tial­ize
non-
    static vari­ables, pro­vided that the mem­ber names are not given."
Dec 01 2012
next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
Bobby Bingham:

 It appears that this form of struct literal really can only be 
 used in initializers -- the assignment to a previously declared 
 varaible fails to compile.

Right. That syntax is not much used in D, there were discussions about deprecating it fully, I don't know the current status. I use it sometimes when I have to initialize an array of many structs.
 I'm hoping somebody can shed some light on the rationale for 
 only supporting this form of struct literal in initializers.

I don't know the rationale. There are tons of things I don't know the rationale of, despite my efforts to learn. The normal way to write a struct literal in D is this, that works in most cases: auto foo = MyStruct(42, 'a');
 And also why it's documented to only work for static
 initializers -- is this an error in the documentation,
 or is the compiler allowing things it shouldn't?

It's another little mystery :-) Maybe the DMD compiler used to allow that, and then specs were updated and the compiler remained unchanged, or the specs where like that since the beginning, but the compiler was closer to a C99 one and allowed it. Or maybe it's just a compiler bug that allows something that is not allowed. Maybe it's Bugzilla worth. Bye, bearophile
Dec 01 2012
prev sibling parent "Rob T" <rob ucora.com> writes:
On Saturday, 1 December 2012 at 19:32:27 UTC, bearophile wrote:
 I don't know the rationale. There are tons of things I don't 
 know the rationale of, despite my efforts to learn.

 The normal way to write a struct literal in D is this, that 
 works in most cases:

 auto foo = MyStruct(42, 'a');


 And also why it's documented to only work for static
 initializers -- is this an error in the documentation,
 or is the compiler allowing things it shouldn't?

It's another little mystery :-) Maybe the DMD compiler used to allow that, and then specs were updated and the compiler remained unchanged, or the specs where like that since the beginning, but the compiler was closer to a C99 one and allowed it. Or maybe it's just a compiler bug that allows something that is not allowed. Maybe it's Bugzilla worth. Bye, bearophile

I'm starting to look into this kind of thing now, although I ave not used struct initializations like that yet for real code, just for my tinkering. In my case I've been fully relying on constructors and initializers, and that seems to be working very well for me, with no reason to change. If you want to perform initializations like that, there is one advantage of specifying the field name: If the struct fields are reordered, then that will not require changes elsewhere, also for example, if you reorder two ints, the code will compile, but will create difficult to detect errors when run. struct X{ int a, b; } X x = { a: 12, b: 13 } ------ struct X{ int b, a; } X x = { 12, 13 } Personally, I think you are far better off using constructors, overloaded opAssign and so forth. Now if you really want to dive into the weirdness of D, then have a look at tuples. Using a tuple, you can perform similar named initializations, and more, but it's far too weird and messy for me to make real use out of, i.e., it is in dire need of a re-think and redesign to make it a clean generalized concept that fits in consistently with the other components of the language. --rt
Dec 01 2012