Thread overview | ||||||||
---|---|---|---|---|---|---|---|---|
|
March 16, 2007 Rectangular or 2d associative arrays | ||||
---|---|---|---|---|
| ||||
Hello All! Look at this small program and look at the output in the comments: /////////////////////////////////// import std.stdio; void main() { int[char] x; // Visually: = ['a':1, 'b':2] // associative array x['b'] = 123; writefln(x); // this prints out: [b:2063597568] writefln(x['b']); // this prints out: 123 } ///////////////////////////////// This just doesn't seem intuitive to me? Why is there a "garbage" value being printed out? Using a linux machine, with dmd 1.009. Cheers! David |
March 16, 2007 Re: Rectangular or 2d associative arrays | ||||
---|---|---|---|---|
| ||||
Posted in reply to David Freitas | David Freitas wrote:
> int[char] x; // Visually: = ['a':1, 'b':2] // associative
> array x['b'] = 123;
> writefln(x); // this prints out: [b:2063597568]
> writefln(x['b']); // this prints out: 123
>
> This just doesn't seem intuitive to me? Why is there a "garbage" value being printed out?
What would you expect D to print out? How can the language know how to interpet arrays of some type? Hard coding some special output format for all types of arrays into the language is not a wise idea.
Falk
|
March 16, 2007 Re: Rectangular or 2d associative arrays | ||||
---|---|---|---|---|
| ||||
Posted in reply to David Freitas | David Freitas wrote: > Hello All! > > Look at this small program and look at the output in the comments: > /////////////////////////////////// > import std.stdio; > void main() { > int[char] x; // Visually: = ['a':1, 'b':2] // associative array > x['b'] = 123; > writefln(x); // this prints out: [b:2063597568] > writefln(x['b']); // this prints out: 123 > } > ///////////////////////////////// > > This just doesn't seem intuitive to me? Why is there a "garbage" value being printed out? > > Using a linux machine, with dmd 1.009. Looks like it's (the value that gets inserted) << 24, or in other words the lower byte is put in the high byte, and the others are cleared. It looks like it's dependent on the key size: if the key type is changed to ushort the upper two bytes are filled with what should be the lower two bytes, and if it's a three-byte struct (with toString) the upper three bytes should be the lower three bytes and the lower byte seems to be garbage. This bug doesn't seem to affect GDC. It looks like gphobos' std.format.doFormat.formatArg.putAArray was patched to make sure access to AA internals is performed on the correct alignment boundary. This may have been done for portability reasons, but I'm guessing it also fixes this bug. Would anyone mind confirming this and submitting a bug + patch to bugzilla? |
March 16, 2007 Re: Rectangular or 2d associative arrays | ||||
---|---|---|---|---|
| ||||
Posted in reply to Falk Henrich | Falk Henrich wrote:
> David Freitas wrote:
>
>> int[char] x; // Visually: = ['a':1, 'b':2] // associative
>> array x['b'] = 123;
>> writefln(x); // this prints out: [b:2063597568]
>> writefln(x['b']); // this prints out: 123
>>
>> This just doesn't seem intuitive to me? Why is there a "garbage" value
>> being printed out?
>
> What would you expect D to print out? How can the language know how to
> interpet arrays of some type? Hard coding some special output format for
> all types of arrays into the language is not a wise idea.
Writef(ln) and other functions that do formatting use the TypeInfo provided by their varargs to construct readable representations of their parameters. This case just seems to be buggy.
|
March 16, 2007 Re: Rectangular or 2d associative arrays | ||||
---|---|---|---|---|
| ||||
Posted in reply to Frits van Bommel | Frits van Bommel wrote:
> Falk Henrich wrote:
>> David Freitas wrote:
>>
>>> int[char] x; // Visually: = ['a':1, 'b':2] //
>>> associative array x['b'] = 123;
>>> writefln(x); // this prints out: [b:2063597568]
>>> writefln(x['b']); // this prints out: 123
>>>
>>> This just doesn't seem intuitive to me? Why is there a "garbage" value being printed out?
>>
>> What would you expect D to print out? How can the language know how to interpet arrays of some type? Hard coding some special output format for all types of arrays into the language is not a wise idea.
>
> Writef(ln) and other functions that do formatting use the TypeInfo provided by their varargs to construct readable representations of their parameters. This case just seems to be buggy.
I wasn't aware of that possibility (TypeInfo). Knowing this, the original
question has more sense...
Falk
|
March 17, 2007 Re: Rectangular or 2d associative arrays | ||||
---|---|---|---|---|
| ||||
Posted in reply to Frits van Bommel | Frits van Bommel wrote: > Falk Henrich wrote: >> David Freitas wrote: >> >>> int[char] x; // Visually: = ['a':1, 'b':2] // associative >>> array x['b'] = 123; >>> writefln(x); // this prints out: [b:2063597568] >>> writefln(x['b']); // this prints out: 123 >>> >>> This just doesn't seem intuitive to me? Why is there a "garbage" value >>> being printed out? >> >> What would you expect D to print out? How can the language know how to >> interpet arrays of some type? Hard coding some special output format for >> all types of arrays into the language is not a wise idea. > > Writef(ln) and other functions that do formatting use the TypeInfo provided by their varargs to construct readable representations of their parameters. This case just seems to be buggy. Probably related to bug 1000: http://d.puremagic.com/issues/show_bug.cgi?id=1000 |
Copyright © 1999-2021 by the D Language Foundation