Operator Let (Assign)operator

Indicates the assignment operator when overloading Operator = (Assignment)

Operatorsoperatordocumented

Syntax

{ Type | Class | Union } typename

Declare Operator Let ( [ ByRef | ByVal ] rhs As datatype )

End { Type | Class | Union }

Operator typename.Let ( [ ByRef | ByVal ] rhs As datatype )

Parameters

Name		Description
`typename`		name of the `Type`, `Class`, or `Union`.
`lhs`		The variable to assign to.
`rhs`		The value to assign.

Description

Let is used to overload the Operator =[>] (Assignment) operator and to distinguish it from the comparison operator Operator = (Equal).

lhs =[>] rhs will assign the rhs to lhs by invoking the Let operator procedure defined in typename.
This includes the case of an object returned from a function by value, by using Function =[>] rhs (or function_identifier =[>] rhs) assignment.

An operator Let (assign) must be defined if the shallow implicit copy is not sufficient. This happens in cases when the object manages dynamically allocated memory or other resources which need to be specially copied (for example if a member pointer points to dynamically allocated memory, the implicit assignment operator will simply copy the pointer value instead of allocate memory and then perform the copy of data).

Note: It is safe to do a check for self-assignment at the top of the Let body (by comparing the address of implicit 'this' instance with the address of 'rhs' parameter) to avoid object destruction if previously allocated memory is first deallocated (see example below).

When the operator Let (assign) is defined for copy assignment, its parameter (the object to clone) can not be passed by value.

Remarks

Usage



lhs = rhs



lhs => rhs

Version

Before fbc version 1.20.0, assigning one array was not supported.

Dialect Differences

In the -lang qb and -lang fblite dialects, this operator cannot be overloaded.
In the -lang qb and -lang fblite dialects, an assignment expression can be preceded by the Let keyword.

Differences from QB

None.

Example

Type UDT

  Public:

    Declare Constructor (ByVal zp As Const ZString Ptr)  ''constructor with string initializer

    Declare Operator Let (ByRef rhs As UDT)              ''operator Let (assignment)

    Declare Function getString () As String              ''function to get string

    Declare Destructor ()                                ''destructor

  Private:         

    Dim zp As ZString Ptr                                ''private pointer to avoid direct access

End Type



Constructor UDT (ByVal zp As Const ZString Ptr)

  This.zp = CAllocate(Len(*zp) + 1)

  *This.zp = *zp

End Constructor



Operator UDT.Let (ByRef rhs As UDT)

  If @This <> @rhs Then  '' check for self-assignment to avoid object destruction

    Deallocate(This.zp)

    This.zp = CAllocate(Len(*rhs.zp) + 1)

    *This.zp = *rhs.zp

  End If

End Operator



Function UDT.getString () As String

  Return *This.zp

End Function



Destructor UDT ()

  Deallocate(This.zp)

End Destructor





Dim u As UDT = UDT("")

u = Type<UDT>("Thanks to the overloading operator Let (assign)")

Print u.getString

Sleep

Output:

Thanks to the overloading operator Let (assign)

Reference

Documented in KeyPgOpLet.html