Re: filling an array of structures

[Ali Çehreli]

Brad wrote:
> Given an array of structures that you need to populate.
> Also assume the structure is quite large and has many
> elements to fill in.
>
> S s[];
> while (something) {
>   s.length += 1;
>   auto sp = &s[$-1];   // method 1
>   sp.a = 1;
>   ...
>   with (s[$-1]) {   // method 2
>     a = 1;
>   }
>   ...
>   foreach (ref sp; s[$-1..$]) {  // method 3
>     sp.a = 1;
>   }
> }
>
> I don't mind 'with' statements, but they have a readability and
> maintenance problem if their scope is large.  The reader would have
> to be aware of the context of the structure and the local variables,
> whereas 'sp.a' is self documenting.
>
> method 3 is fine, and provides me with a reference to s[$-1],
> but I'd really like to have:
>    auto sp = ref s[$-1];  // possible method 4
> where sp is a reference, but no pointer arithmetic can be done on it.
>
> Another alternative would be runtime aliases.
>    alias s[$-1] as sp;
> Or
>    sp = with (s[$-1]); // I don't much like this syntax...
>
> In the meantime, I'll go with method 1.
>
>   -- Brad
I've been using a method in C++, which involves

    boost::shared_ptr
    boost::enable_from_shared
    boost::list_of

That was useful when objects had both some required and some optional 
properties. Anyway... If polymorphism is not needed something similar 
can be achieved very simply in D:

    S[] esses = [ S(42), S(100).optional(3) ];

The whole code:

import std.stdio;
import std.string;

struct S
{
    int must_have_;
    int optional_;

    this(int must_have)
    {
        must_have_ = must_have;
    }

    ref S optional(int optional_arg)
    {
        optional_ = optional_arg;
        return this;
    }

    string toString() const
    {
        return format("%s.%s", must_have_, optional_);
    }
}

void main()
{
    S[] esses = [ S(42), S(100).optional(3) ];
    writeln(esses);
}

Ali