Const (Qualifier)
Specifies that a data type or pointer data type is read only.
Syntax
`
... As [Const] datatype [ [Const] Ptr ... ]
`
Parameters
`datatype`
Name of a standard or user defined data type.
Description
Specifies that the `datatype` or `Ptr` immediately to the right of the `Const` qualifier is to be considered as read only. Read-only (`Const`) declarations are a measure of type safety that can be read as 'promises not to change.' The compiler uses the const declarations to check operations on variables and parameters and generate an error at compile time if their data could potentially change. There is no runtime overhead for using `Const` qualifiers since all of the checks are made at compile time.
`Const` can be used anywhere data type declarations are made. This includes variables, parameters, function return results, user defined type fields, type aliases, and casting. The `datatype` can be any built-in standard data type or user defined type.
Read-only variables must have an initializer since modifying a read-only variable through an assignment will generate a compiler error. The initializer may appear after the declaration of the variable.
Both non-const and const variables may be passed to a procedure expecting a const parameter. However, a const variable may not be passed to a procedure taking a non-const parameter, and will generate a compile error.
Procedures can be overloaded based on the const-ness of parameters. For example a procedure can be overloaded where one version of the procedure takes a `'byref foo as bar'` parameter and another version of the procedure takes a `'byref foo as const bar'` parameter.
With pointer declarations, `Const` can be used to indicate which part of the pointer declaration is read-only (all other parts are by default read-write). The read-only portion of the pointer data type could be the pointer itself (the address), what the pointer points to (the data), or both. In a declaration with more than one level of `Ptr` indirection, the right most `Ptr` indicates the highest order level of indirection and is therefore dereferenced first.
The compiler has an internal hard-limit of eight (8) levels of pointer indirection with respect to const qualifiers and the behavior of using `Const` with `Ptr` data types having greater than eight (8) levels of indirection is undefined.
Example
`
'' Const Variables
'' procedure taking a const parameter
Sub proc1( ByRef x As Const Integer )
'' can't change x because it is const
'' x = 10 '' compile error
'' but we can use it in expressions and
'' assign it to other variables
Dim y As Integer
y = x
y = y * x + x
End Sub
'' procedure taking a non-const parameter
Sub proc2( ByRef x As Integer )
'' we can change the value
x = 10
End Sub
'' declare a non-const and const variable
Dim a As Integer
Dim b As Const Integer = 5
'' proc1() will accept a non-const or const
'' argument because proc1() promises not to
'' change the variable passed to it.
proc1( a )
proc1( b )
'' proc2() will accept a non-const argument
proc2( a )
'' but not a const argument because proc2()
'' might change the variable's data and we
'' promised that 'b' would not change.
'' proc2( b ) '' compile error
`
`
'' Const Pointers
'' an integer
Dim x As Integer = 1
Dim y As Integer = 2
Dim z As Integer = 3
'' To check that the compiler generates errors
'' when attempting to reassign const variables,
'' uncomment the assignments below.
''
Scope
'' a pointer to an integer
Dim p As Integer Ptr = @x
p = @y /' OK - pointer can be changed '/
*p = z /' OK - data can be changed '/
End Scope
''
Scope
'' a pointer to a constant integer
Dim p As Const Integer Ptr = @x
p = @y /' OK - pointer can be changed '/
'' *p = z /' Error - data is const '/
End Scope
''
Scope
'' a constant pointer to an integer
Dim p As Integer Const Ptr = @x
'' p = @y /' Error - pointer is const '/
*p = z /' OK - data can be changed '/
End Scope
''
Scope
'' a constant pointer to a constant integer
Dim p As Const Integer Const Ptr = @x
'' p = @y /' Error - pointer is const '/
'' *p = z /' Error - data is const '/
End Scope
`
`
'' Const Parameters in an Overloaded Procedure
'' procedure with non-const parameter
Sub foo Overload( ByRef n As Integer )
Print "called 'foo( byref n as integer )'"
End Sub
'' procedure with const parameter
Sub foo Overload( ByRef n As Const Integer )
Print "called 'foo( byref n as const integer )'"
End Sub
Dim x As Integer = 1
Dim y As Const Integer = 2
foo( x )
foo( y )
'' OUTPUT:
'' called 'foo( byref n as integer )'
'' called 'foo( byref n as const integer )'
`
Differences from QB

- New to FreeBASIC

See also

- `Const`
- `Const (Member)`
- `Dim`
- `Type`