Next: , Previous: , Up: Arrays   [Contents][Index]

#### 18.4.3 Casting Arrays

There are two kinds of casts for array values:

• Cast to array types that may have a different bounding.
• Cast of array of integers or integral structs to an integral type.

For example, we have seen that the type of an array literal is always bounded by a constant number of elements. Thus the type of `[1,2,3]` is `int[3]`.

We could cast the value above to an unbounded array type by doing:

```[1,2,3] as int[]
```

Or to an array bounded by size:

```[1,2,3] as int[12#B]
```

Of course trying to cast an array value to a type for which the bounding restrictions will fail. This will give you a compile-time error:

```[1,2,3] as int[4]
```

And this will result in a run-time error:

```(poke) [1,2,3] as int[13#B]
unhandled conversion error exception
```

Now let’s see how Poke reinterprets integral arrays as integers:

```(poke) [0xdeUB,0xadUB] as uint16
```

Trying to cast an array with a size larger than 64-bit will result in an error:

```(poke) [1,2,3] as int
unhandled conversion error exception
arrays bigger than 64-bit cannot be casted to integral types
```

It also works for nested arrays and arrays of integral structs (See Integral Structs):

```(poke) type Foo = struct uint { int16 hi; int16 lo; };
(poke) [[Foo{ hi=0xdeadH, lo=0xbeefH}],[Foo{}]] as ulong
The way it works is like putting all array elements in an `uint<64>` number and then casting that number to the destination integral type.