On 09/11/2010 12:42, Steven Schveighoffer wrote:
On Mon, 08 Nov 2010 21:29:42 -0500, Jesse Phillips
<[email protected]> wrote:
Well, if you can come up with a good definition for what "increasing
the size of a class" would do, then maybe it should be added.
It really doesn't matter. Arrays are their own type, the have their
own semantics. It does help to think of them in terms of slices (which
is what TDPL refers to them as), yet that does not remove the fact
that they are in dead a reference type.
Many times familiar terms are used so that a behavior is quickly
understood. For example it is common to say that arrays in C is just a
pointer into a memory location. But in reality that is not true.
It depends on your definition of reference type. I agree with Daniel. If
you want to get into academic definitions, yes, 'technically' an array
is a reference, but it's confusing to someone who's not interested in
exploring the theoretical parts of computer science.
What do you mean "depends on your definition of reference type" ? I
think that what a reference type is, is generally understood fairly well
by the majority of developers, even if understood implicitly. I think
our confusion here has more to do to what we consider an "array", rather
than what we consider to "reference type to be. See below.
I think of an array as a hybrid between a reference and a value type.
The data is passed by reference, the length is passed by value. This
mean changing the length only affects the local copy, but changing the
data affects all arrays that point to that data.
Well, saying _dynamic arrays_ are a hybrid, like you mentioned, is
perhaps the best way to describe them, with less misunderstanding.
However, if I had to say whether dynamic arrays are value types or
reference types, I would agree with Jesse and call them reference types,
and I would not feel this is inaccurate. Let's try a test everyone, look
at this code:
void test() {
int[] a = [1, 2, 3];
int[] b = a;
int[] c = a;
}
and tell us, what you would you reply if asked "how many arrays are
created during test's scope"? I would say "1", and not feel it is
inaccurate. However, if asked how "many dynamic arrays are created
during test's scope?", I would likely say "3".
This is because what I consider an array to *be*, is its (contiguous &
homogeneous) elements. With that definition, then D's static arrays are
value types, because when you assign a static array value to a static
array variable, the underlying _array_ (ie, the contents), get copied.
Conversely, D's dynamic arrays are reference types, because when you
assign a dynamic array value to a dynamic array variable, the underlying
"array" (ie, the contents) are not copied, instead you get two
references to exactly the same "array" (ie, same data). This viewpoint
gets a bit murkier because an "array" can be contained inside another
"array", but that doesn't fundamentally change the it (the viewpoint
that is).
But ultimately neither view is right or wrong, it just depends on how we
define our terms, how we conceptualize things. However, it's probably
best to stick to what the spec/TDPL says about it, if it says anything
specific. (I don't think it does though :/ ) Or to avoid ambiguous
designations.
... Oh man, I need to clear my head.
--
Bruno Medeiros - Software Engineer
