{{fbdoc item="title" value="ANY"}}----
The ##**Any**## keyword is used as a placeholder for a type or value in various ways.

{{fbdoc item="syntax"}}##
	[[KeyPgDim|Dim]] //identifier// [[KeyPgAs|As]] **Any** [[KeyPgPtr|Pointer]]|[[KeyPgPtr|Ptr]]
##//or//##
	[[KeyPgDeclare|Declare]] [[KeyPgSub|Sub]]|[[KeyPgFunction|Function]] //identifier// ( [[KeyPgByref|Byref]] //identifier// [[KeyPgAs|As]] **Any** [ , ... ] )
##//or//##
	[[KeyPgDim|Dim]] //identifier//(**Any** [, **Any**...]) [[KeyPgAs|As]] [[DataType|DataType]]
##//or//##
	[ [[KeyPgDeclare|Declare]] ] { [[KeyPgSub|Sub]] | [[KeyPgFunction|Function]] } //proc_name// ( //param//(**Any** [, **Any**...]) [[KeyPgAs|As]] [[DataType|DataType]]  )
##//or//##
	[[KeyPgDim|Dim]] //identifier// [[KeyPgAs|As]] [[DataType|DataType]] = **Any**
##//or//##
	[[KeyPgOpNew|New]] [[DataType|DataType]] **( Any )**
##//or//##
	[[KeyPgOpPlacementNew|New(address)]] [[DataType|DataType]] [//count//] **{ Any }**
##//or//##
	[[KeyPgInstr|Instr]]|[[KeyPgInstrrev|InstrRev]] ( //identifier//, **Any** //substring// )
##//or//##
	[[KeyPgOpProcptr|Procptr]] ( //identifier//, [[[KeyPgVirtual|Virtual]]] **Any** )
##
{{fbdoc item="desc"}}
	- Pointers (1st syntax):
		A special pointer type called the ##**Any** [[KeyPgPtr|Ptr]]## (or "##**Any** [[KeyPgPtr|Pointer]]##") allows pointing to any variable type.  If you cast it to a ##//[[DataType]]// [[KeyPgPtr|Ptr]]##, it can be indexed or dereferenced to access the memory as an instance of ##//[[DataType]]//##. Pointer arithmetic is allowed on an ##**Any** Ptr##, and treats it like a ##[[KeyPgByte|Byte]] Ptr##: The pointer is changed by increments of ##1##.
		
		A pure ##**Any** [[KeyPgPtr|Ptr]]## has no type checking by the compiler.  It can be implicitly converted to and from other pointer types through assignment or parameter passing.
		
		##**Any**## on its own is not a valid data type for a variable. Also, it is illegal to dereference an ##**Any** Ptr## (although an ##**Any** Ptr Ptr## may be dereferenced to produce a ##**Any** Ptr##).
		
		This should not be confused with ##**Variant**##, a Visual Basic data type which can contain any type of variable. ""FreeBASIC"" does not provide native support for a ##**Variant**## type.
		
	- Byref parameters (2nd syntax):
		**##Any##** can be used in procedure prototypes (in a ##[[KeyPgDeclare|Declare]]## statement) with ##[[KeyPgByref|ByRef]]## parameters to disable the compiler checking for the correct type of the variable passed (this includes the array parameters because always implicitly passed by reference).
		Obviously, this does not work with overload procedures, and therefore neither with UDT member procedures.
		This use of ##**Any**## exists for compatibility with QB, but can be superseded by procedure overloading.
		
	- Array dimensions (3rd/4th syntax):
		In array declarations, **##Any##** can be specified in place of the array bounds in order to create a dynamic array with a certain amount of dimensions that is determined based on the number of **##Any##**s specified (use the syntax with **##Any##** is mandatory when declaring a dynamic array member inside a ##[[KeyPgType|Type]]##).
		
		In parameter declarations, **##Any##** can be also specified instead of empty parenthesis in order to fix the amount of dimensions.
		
	- Initialization (5th/6th/7th syntax):
		##**Any**## can be used as a fake initializer to disable the default initialization of variables to ##0##, leaving the variable uninitialized. This may save time in critical sections of a program. It is the program's responsibility to fill the variables with meaningful data before reading it.
		
		For a UDT, the member data fields are also not initialized, and the default constructors, if they exist, are not called.
		
		Comparison to ""C/C++"": This matches the behavior of a variable declaration without initialization value in ""C/C++"".
		
		##**Any**## is not allowed when the ##//[[DataType]]//## is a var-len ##[[KeyPgString|String]]##, because there is no string character data, and not initializing the descriptor would be an aberration.
		
		For a var-len array, **##Any##** is used only once at the declaration level, not at each resize level with ##[[KeyPgRedim|Redim]]## (##[[KeyPgErase|Erase]]## does not reset this initialization state).
		
		Similar to **##Any##** initializers for variables, **##Any##** can also be used with the ##[[KeyPgOpNew|New Expression]]## or ##[[KeyPgOpPlacementNew|Placement New]]## operators in order to leave the newly created object uninitialized (only allowed with data types that do not have a constructor, also excluding the var-len string type).
		
	- ""Instr/InstrRev"" (8th syntax):
		**##Any##** can be used with ##[[KeyPgInstr|Instr]]## or ##[[KeyPgInstrrev|InstrRev]]## as a qualifier for the ##//substring//## parameter, to indicate that any individual character in it may be matched.
		
	- Procptr (9th syntax):
		**##Any##**, ie any procedure signature, does not induce any particular selection (compared to its non-use), but just allows for writing ##[[KeyPgOpProcptr|Procptr]]## always with 2 arguments.

{{fbdoc item="ex"}}
{{fbdoc item="filename" value="examples/manual/misc/any.bas"}}%%(freebasic)
Declare Sub echo(ByVal x As Any Ptr) '' echo will accept any pointer type

Dim As Integer a(0 To 9) = Any '' this variable is not initialized
Dim As Double  d(0 To 4)

Dim p As Any Ptr

Dim pa As Integer Ptr = @a(0)
Print "Not initialized ";
echo pa       '' pass to echo a pointer to integer

Dim pd As Double Ptr = @d(0)
Print "Initialized ";
echo pd       '' pass to echo a pointer to double

p = pa     '' assign to p a pointer to integer
p = pd     '' assign to p a pointer to double      

Sleep

Sub echo (ByVal x As Any Ptr)
	Dim As Integer i
	For i = 0 To 39
		'echo interprets the data in the pointer as bytes
		Print Cast(UByte Ptr, x)[i] & " ";
	Next
	Print
End Sub
%%

{{fbdoc item="filename" value="examples/manual/misc/any-param.bas"}}%%(freebasic)
'Example of ANY disabling the variable type checking
Declare Sub echo (ByRef a As Any) '' ANY disables the checking for the type of data passed to the function

Dim x As Single
x = -15
echo x                  '' Passing a single to a function that expects an integer. The compiler does not complain!!             
Sleep

Sub echo (ByRef a As Integer)
  Print Hex(a)         
End Sub

%%

{{fbdoc item="filename" value="examples/manual/misc/any-dynamic-array.bas"}}%%(freebasic)
Dim a(Any) As Integer ' 1-dimensional dynamic array
Dim b(Any, Any) As Integer ' 2-dimensional dynamic array
Dim c(Any, Any, Any) As Integer ' 3-dimensional dynamic array
' etc.

' Further Redims or array accesses must have a matching amount of dimensions
Redim a(0 to 1)
Redim b(1 to 10, 2 to 5)
Redim c(0 to 9, 0 to 5, 0 to 1)
%%

{{fbdoc item="lang"}}
	- Not available in the //[[CompilerOptlang|-lang qb]]// dialect.

{{fbdoc item="diff"}}
	- Pointers and initializers are new to ""FreeBASIC"".

{{fbdoc item="see"}}
	- ##[[KeyPgDim|Dim]]##
	- ##[[KeyPgDeclare|Declare]]##

{{fbdoc item="back" value="CatPgProcedures|Procedures"}}