Operator Delete Statement
Operator to destroy data and free memory allocated with the `Operator New Expression`
Usage
`
Delete buf
or
Delete[] buf
`
Parameters
`buf`
A pointer to memory that has been allocated by `New Expression` operator or `New[] Expression` operator, the array-version of `New Expression` operator (a typed pointer must be provided in accordance to the data type to delete).
Description
The `Delete Statement` operator is used to destroy and free the memory of an object created with `New Expression` operator. When deleting a TYPE, its destructor will be called. `Delete Statement` operator should only be used with addresses returned from `New Expression` operator.
The array version of `Delete Statement` operator, `Delete[] Statement` operator, is used to destroy an array of objects previously created with `New[] Expression` operator, the array-version of `New Expression` operator. Destructors will be called here as well.
`Delete Statement` operator must be used with addresses returned from `New Expression` operator, and `Delete[] Statement` operator with `New[] Expression` operator, the array-version of `New Expression` operator. You cannot mix and match the different versions of the operators.
After the memory is deleted, the `buf` pointer will be pointing at invalid memory. Calling `Delete Expression` twice on the same pointer value leads to undefined behavior. It may be a good idea to set the `buf` pointer to null (`0`), in order to guard against later code using it accidentally, since null pointer dereferences are easier to find and debug.
Calling `Delete Statement` operator on a null pointer induces no action.
The memory deallocation process part provided by the `Delete Statement` operator can be overloaded for user-defined types as a member operator `Delete Overload`. The previous process part for data destruction can never be modified.
Note: Any operator `Delete[] Statement` (or the only overload operator `Delete Statement`) is not compatible with sub-type polymorphism, even using `Override` `Virtual` `Destructor` that may in addition induce crashing.
Instead of having to call such an operator `Delete([]) Statement` on derived-type pointer, the safest way is to simply call (on base-type pointer) an overridden user `Virtual` member procedure that will automatically launch the operator `Delete([]) Statement` at derived-type level.
Example
`
Type Rational
As Integer numerator, denominator
End Type
' Create and initialize a Rational, and store its address.
Dim p As Rational Ptr = New Rational(3, 4)
Print p->numerator & "/" & p->denominator
' Destroy the rational and give its memory back to the system.
Delete p
' Set the pointer to null to guard against future accesses
p = 0
`
`
' Allocate memory for 100 integers, store the address of the first one.
Dim p As Integer Ptr = New Integer[100]
' Assign some values to the integers in the array.
For i As Integer = 0 To 99
p[i] = i
Next
' Free the entire integer array.
Delete[] p
' Set the pointer to null to guard against future accesses
p = 0
`
Dialect Differences

- Only available in the -lang fb dialect.

Differences from QB

- New to FreeBASIC

See also

- `New Expression`
- `Delete Overload`
- `Deallocate`