Guess the output (Union)

[ErosOlmi]

Giving the following UNION and relative variable ...

Union MyUnion
  b(12)   As Byte
  st      As String * 12
End Union

Dim MyU As MyUnion

Giving one of the following two methods to fill the union array b ...

'---Method 1 to fill UDT array
  With MyU
    .b( 1) = 116
    .b( 2) = 104
    .b( 3) = 105
    .b( 4) = 110
    .b( 5) = 66
    .b( 6) = 97
    .b( 7) = 115
    .b( 8) = 105
    .b( 9) = 99
    .b(10) = 32
    .b(11) = 33
  End With

'---Method 2 to fill UDT array
  With MyU
    .b( 1) = 116, 104, 105, 110, 66, 97, 115, 105, 99, 32, 33
  End With

What will be the output of:

MsgBox 0, MyU.st

[Petr Schreiber]

Hehe,

since PB/DOS I have the ASCII table in my head, so I am quite sure the result will be "thinBASIC !"

UNIONs are cool feature when porting from other languages, but in practice I use more the DIM .. AT syntax to achieve same result in most projects.

I think in this special case it is enough to have the array dimensioned to 11 elements and the string to 11 characters.

Why?

Because STRING * n is not null terminated, which is the difference compared to ASCIIZ * n.

So the code could be in theory this (added one method for array fill):

Union MyUnion
  b(11)   As Byte
  st      As String * 11
End Union
 
Dim MyU As MyUnion

'---Method 1 to fill UDT array
  With MyU
    .b( 1) = 116
    .b( 2) = 104
    .b( 3) = 105
    .b( 4) = 110
    .b( 5) = 66
    .b( 6) = 97
    .b( 7) = 115
    .b( 8) = 105
    .b( 9) = 99
    .b(10) = 32
    .b(11) = 33
  End With
 
'---Method 2 to fill UDT array    
  With MyU
    .b( 1) = 116, 104, 105, 110, 66, 97, 115, 105, 99, 32, 33
  End With
  
'---Method 3 to fill UDT array  
  MyU.b( 1) = 116, 104, 105, 110, 66, 97, 115, 105, 99, 32, 33  
  
MsgBox 0, MyU.st

Petr

[ReneMiner]

I always wanted to know what that "Union" does.

Now I think I've learned from this thread that st and b of myU refer to the same adress in memory and both display the same values stored as different types. Just for interest: I could replace some "cast"-Methods (cstr, cbyte etc.) by using a Union, for example I could use

Union someUnion
    l as long
    b(4) as Byte
End Union

dim myU as someUnion
myU.l = 123456

' now the b()-bytes show the value 123456 split up to &H00, &H01, &HE2 and &H40 ? Cool.

[ErosOlmi]

@Petr: right you are.
ASCIIZ * n needs 12 bytes (due to NULL at the end) while for STRING * n 11 bytes are enough.


@ReneMiner

... st and b of myU refer to the same address in memory and both display the same values stored as different types.

Exactly: every element into an UNION shares the same memory area with all the other elements.
The total memory area occupied by an UNION is the size of the longest element present into the UNION.

Here a little more interesting UNION example

Uses "console"


'---3 different structures each of which representing a thing: dog, orange, coin
  Type Dog
      lBreed     As Long
      lAge       As Byte
      sName      As String * 16
  End Type
   
  Type Orange
      lSize      As Byte
  End Type
   
  Type Coin
      lCountry   As Long
  End Type


'---Put all the things together into an union so they all share the same memory area
  Union ThingProperties
      tDog      As Dog
      tOrange   As Orange
      tCoin     As Coin
  End Union   


'---Now creates a general purpose thing able to represent all the possible things
  Type Thing
      lThingType     As Long
      uThingProp     As ThingProperties
  End Type


'---Possible things type
  %ORANGE = 1
  %COIN   = 2
  %DOG    = 3


'---Allocate few things
  Dim tThing(3)     As Thing
  Dim lCurrentThing As Long


'---Fill things with a thing type and thing data
  tThing(1).lThingType                = %ORANGE
  tThing(1).uThingProp.tOrange.lSize  = 25


  tThing(2).lThingType                = %COIN
  tThing(2).uThingProp.tCoin.lCountry = 1234


  tThing(3).lThingType                = %DOG
  tThing(3).uThingProp.tDog.sName     = "FUFFY"
  
'---Show something a bout the things
  For lCurrentThing = 1 To UBound(tThing)
    Print "Thing is ... "
    Select Case tThing(lCurrentThing).lThingType
      Case %ORANGE
        PrintL "an Orange of size"    , tThing(lCurrentThing).uThingProp.tOrange.lSize
      Case %COIN
        PrintL "a Coin by country"    , tThing(lCurrentThing).uThingProp.tCoin.lCountry
      Case %DOG
        PrintL "a Dog whose name is"  , tThing(lCurrentThing).uThingProp.tDog.sName
    End Select
  Next


WaitKey