data type of array ?

SUNIL GUTTA

Hie friends

Well array in general its a grouping of similar datatypes [int or char or string] :) as all know it

But my doubt is, FIXED length types are VALUES types if i am not wrong ?? so we can store them in stack :)

While memory allocated at run-time like strings ,objects etc are variable length humm .!! so they are reference types [storage:managed heap]:) right ?

SO problem is ARRAY is a fixed length type even tough it called as Reference types why cant we call it as value type :( ?

I guess as array's group's strings also that's why its called as reference type as string is a reference type

Hope everyone got my problem & waiting for your solution in general in ur own view :) no links plz for this

7 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
Accepted answer
Well, when we talk about arrays being fixed-length all we really mean is that once the array has been created its length cannot be changed.

However, as it happens, the amount of heap memory occupied by the array object itself is also fixed.

As you said, when it's an array of value types (int, bool, double, char etc) each element of the array contains the value type itself which requires a fixed amount of storage - 4 bytes for an int, 1 byte for a bool, 8 bytes for a double, 2 bytes for a char etc.

When its an array of reference types, each array element contains a reference (i.e. a pointer) to where the actual reference type object is stored elsewhere on the heap. These references are also fixed in size - 4 bytes on a 32-bit system and 8 bytes on a 64-bit system.

So, if you had an array of 10 strings on a 32-bit system, the array elements would occupy 40 bytes on the heap. The strings themselves, which would be stored elsewhere on the heap, would (ignoring overhead) need 2 x n bytes where n is the length of the string (each unicode character requires 2 bytes of storage).
Vulpes13y ago
I don't think that the amount of overhead used by a .NET string is officially documented but it's thought to be 20 bytes on a 32-bit system or 32 bytes on a 64-bit system.

All objects (string or otherwise) have 8 bytes of overhead (16 bytes on a 64-bit system) consisting of:

1. A pointer to the object's method table.

2. An index into an array of 'sync blocks' maintained by the runtime which are mainly used for thread synchronization purposes.

In addition, strings have the following overhead:

3. Their actual length (4 bytes).

4. Their capacity (4 bytes) which may be more than the actual length when strings are created using the StringBuilder class.

5. A null character (2 bytes) which is placed at the end of the string's characters (though it's not part of the string itself). This is useful for interoperating with unmanaged code which uses null terminated strings.

So if you add all this up, you get 18 bytes for a 32-bit system or 26 bytes for a 64-bit system which are then rounded up to be exactly divisible by 4 or 8 respectively.

Whilst the memory overhead may seem high, it needs to be remembered that it's always the same regardless of the length of the string.
SUNIL GUTTA13y ago
Yes yes got it TY :)

ignoring overhead ? U said that .. well what excatly overhead contains as it occupies 2bytes in heap out of 4 ?
Vulpes13y ago
It would actually be 2 x 6 = 12 bytes for the characters themselves as I'd already allowed for the fact that string characters are always unicode in the 2 x n formula in my earlier post.
SUNIL GUTTA13y ago
super super explanation i liked this concept :)

each unicode character requires 2 bytes of storage ??

this means if humm lets take this string in array like "Vulpes" :) so total memory on heap will be 2 * 2(6) = 24 bytes of memory haaa ??

TY
Vulpes13y ago
That's right.

There's an essential difference between an array of value types and an array of reference types. The former is entirely self contained and the latter contains references to the objects themselves which are stored outside the array.
SUNIL GUTTA13y ago
TY for detailed explanation i am so thankful to you :)

Well then i conclude on behalf of you :) array datatype can't be classified acc to their length[fixed or variable] but mainly done acc to their storage way[value or refernce] ri8 :)