Saaa wrote:
Jeremie Pelletier wrote:
You cannot have static array be ref or out. You must use int[] arr instead
and let the caller specify the length.
Array in D are already references to their data, it's a 8bytes (or 16bytes
on x64) value containing a pointer and a length.
Ok, this I got correct :)
So the following prototype: void func(<none>/in/ref/out int[] arr);
would have the following semantics:
"<none>" copies the array reference, the referenced data is mutable.
Modifying the local reference does not change the caller's reference.
Modifying the local referenced data does not change the caller's referenced
data.
So only if the referenced data is mutated, a copy will be made?
Test seems to back this up.
What I meant is that modifying the local reference does not change the
caller's reference, but both references point to the same data.
"in" copies the array reference, the local reference AND the referenced
data are immutable in the method's scope.
What, there is a difference between <none> and "in" ??
Where can I about read this?
In the example "int foo(int x, ..." on the functions page x is "in".
Are we maybe talking about a different D? D1
I really really wish to understand this stuff.
<info> I know about how in c a function stack is created.
I don't think theres a difference in D1, in D2 there is:
void Foo(in int[] bar);
here typeof(bar).stringof would say const(int[]).
http://digitalmars.com/d/2.0/function.html
"If no storage class is specified, the parameter becomes a mutable copy
of its argument."
"ref" passes a reference to the caller's array reference, the referenced
data is mutable. Modifying the local reference also changes the caller's
reference.
Same as <none> except that it doesn't create a copy on mutate?
Not the same, no storage class will make a copy of the reference, which
points to the same data as the caller's reference. "ref" makes a
reference to the caller's reference, so you can modify it *and* the data
it points to.
Here's an example:
void main() {
int[] arr = new int[64];
arr[0] = 10;
foo(arr);
assert(arr.length == 10); // True because foo changed our reference
with its own
}
void foo(ref int[] arr) {
assert(arr[0] == 10); // True because arr points to the same data
as the caller's
arr = new int[10];
}
This is the difference between being able to modify the array data and
the array reference.
"out" passes a reference to the caller's array reference. The referenced
array reference is zeroed and can be modified by the local reference.
Compared to returning a locally(to the function) created array, here
no allocation might be needed if the passed array is big enough.
"out" does not create the array data, only a reference to a null array
reference in the caller's frame. You still need to allocate data for the
array. Take the above example and change ref to out, the assert in foo
would fail because arr is set to a null reference, but the assert in
main would succeed because foo modified it.
If you want a mutable reference to an immutable view on the referenced
data, use const(int)[], which can also be ref or out.
out const(int)[] will create a array of zero's which you cannot change?
No, it will nullify the reference it is given allowing the method to
assign a new reference to it for the caller to use, but wont be able to
modify its data after assigning the reference.
Why isn't there a nice table about this?
columns: local reference/data with/without mutation, caller reference/data
with/without mutation
rowns: <none>, in, out, ref
cells: array.ptr/length/data
Or, where should I put it after creating it.
I had to learn it through trial and error myself :) If you do make such
a table you could submit it as an improvement in bugzilla.
void func(in/out/ref int i)
"<none>" would be a mutable copy.
"in" would be immutable copy.
I can't get over the idea that in and none aren't the same
Really, D1? :D
In my test program I can change local i using "in"
"out" is a reference to the caller's int initialized to 0.
"ref" is a reference to the caller's int.
"in" and "const" are only really useful with types which are already
references, such as pointers, arrays and objects.
Hope I got it right..
Oops, I was talking in the context of D2, where 'in' is an alias for
'const scope'.
