FreeBasic Return Keyword

Last modified April 20, 2026

The FreeBasic Return keyword is used to exit a function or subroutine and optionally return a value. It plays a crucial role in controlling program flow and passing data between procedures.

Basic Definition

In FreeBasic, Return is a statement that immediately exits the current function or subroutine. In functions, it can return a value to the caller. In subroutines, it simply exits without returning a value.

The Return statement can appear anywhere in a procedure. When executed, it transfers control back to the calling code. Multiple return points are allowed but should be used judiciously for code clarity.

Simple Function Return

This example shows a basic function using the Return statement.

Function AddNumbers(a As Integer, b As Integer) As Integer
 Dim result As Integer = a + b
 Return result
End Function
Dim sum As Integer = AddNumbers(5, 7)
Print "The sum is: "; sum

The AddNumbers function takes two integers, adds them, and returns the result. The Return statement passes the value back to the caller. This is the most common use of Return in functions.

Early Return from Function

Return can be used to exit a function before reaching its end.

Function IsPositive(n As Integer) As Boolean
 If n > 0 Then
 Return True
 End If
 
 Return False
End Function
Print "Is 10 positive? "; IsPositive(10)
Print "Is -5 positive? "; IsPositive(-5)

This function checks if a number is positive. It uses an early return when the condition is met. The second return handles the false case. This pattern is common in validation functions.

Return from Subroutine

Subroutines can use Return to exit early, though they do not return values.

Sub PrintIfPositive(n As Integer)
 If n <= 0 Then
 Print "Number is not positive"
 Return
 End If
 
 Print "The positive number is: "; n
End Sub
PrintIfPositive(8)
PrintIfPositive(-3)

This subroutine prints a number only if it is positive. The Return statement exits early for non-positive numbers. Subroutines use Return for control flow without returning values.

Returning Multiple Values

FreeBasic allows returning multiple values using user-defined types.

Type Point
 x As Integer
 y As Integer
End Type
Function CreatePoint(x As Integer, y As Integer) As Point
 Dim p As Point
 p.x = x
 p.y = y
 Return p
End Function
Dim origin As Point = CreatePoint(0, 0)
Print "Point coordinates: "; origin.x; ", "; origin.y

This example demonstrates returning a compound type. The function creates and returns a Point structure. Return can handle complex types just like simple values.

Return in Recursive Functions

Return is essential for recursive functions to unwind the call stack.

Function Factorial(n As Integer) As Integer
 If n <= 1 Then
 Return 1
 End If
 
 Return n * Factorial(n - 1)
End Function
Print "5! = "; Factorial(5)

This recursive factorial function uses Return for both the base case and recursive case. Each return passes a value back up the call stack. Recursion demonstrates Return's role in nested function calls.

Return with Reference Parameters

Functions can modify reference parameters before returning.

Function ProcessString(ByRef s As String) As Boolean
 If Len(s) = 0 Then
 Return False
 End If
 
 s = UCase(s)
 Return True
End Function
Dim text As String = "hello"
If ProcessString(text) Then
 Print "Processed string: "; text
Else
 Print "Empty string provided"
End If

This function modifies a string by reference and returns a status. The Return statement provides feedback about the operation's success. This pattern combines output parameters with return values.

Return in Main Function

The main program can use Return to specify an exit code.

Function Main() As Integer
 Print "Program starting..."
 
 ' Program logic here
 
 Print "Program ending normally"
 Return 0
End Function

In FreeBasic, the main function can return an integer exit code. Return 0 typically indicates success. Non-zero values often represent error codes. This is useful for scripting and batch processing.

Best Practices

• Clarity: Use Return statements that are easy to follow.
• Consistency: Maintain consistent return patterns.
• Documentation: Document return values in comments.
• Error Handling: Use return codes for error conditions.
• Single Exit: Consider single exit points for complex functions.

This tutorial covered the FreeBasic Return keyword with practical examples showing its various uses in functions and subroutines.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all FreeBasic Tutorials.