Declaring Variables

Variables must be declared before they are used. Unique names are used to identify variables. To declare a variable, you must specify its type and a unique name. Declaration of variable is not an operator.

Simple types are:

  • char, short, int, long, uchar, ushort, uint, ulong – integers;
  • color – integer representing the RGB-color;
  • datetime – the date and time, an unsigned integer containing the number of seconds since 0 hour January 1, 1970;
  • bool – boolean values true and false;
  • double – double-precision floating point number;
  • float – single-precision floating point number;
  • string – character strings.


string szInfoBox;
int    nOrders;
double dSymbolPrice;
bool   bLog;
datetime tBegin_Data   = D'2004.01.01 00:00';
color    cModify_Color = C'0x44,0xB9,0xE6';

Complex or compound types:

Structures are composite data types, constructed using other types.

struct MyTime
   int hour;    // 0-23
   int minute;  // 0-59
   int second;  // 0-59
MyTime strTime; // Variable of the previously declared structure MyTime

You can't declare variables of the structure type until you declare the structure.


Array  is the indexed sequence of identical-type data:

int    a[50];       // One-dimensional array of 50 integers.
double m[7][50];    // Two-dimensional array of seven arrays,
                    // each of them consisting of 50 numbers.
MyTime t[100];      // Array containing elements such as MyTime

Only an integer can be an array index. No more than four-dimensional arrays are allowed. Numbering of array elements starts with 0. The last element of a one-dimensional array has the number which is 1 less than the array size. This means that call for the last element of an array consisting of 50 integers will appear as a[49]. The same concerns multidimensional arrays: A dimension is indexed from 0 to the dimension size-1. The last element of a two-dimensional array from the example will appear as m[6][49].

Static arrays can't be represented as timeseries, i.e., the ArraySetAsSeries() function, which sets access to array elements from the end to beginning, can't be applied to them. If you want to provide access to an array the same as in timeseries, use the dynamic array object.

If there is an attempt to access out of the array range, the executing subsystem will generate a critical error and the program will be stopped.

Built-in methods for working with arrays #

The functions from the Array Functions section, as well as the built-in methods can be used to handle the arrays:




void array.Fill(const scalar value, const int start_pos=0, const int count=-1);

ArrayFill, ArrayInitialize

Fills the array with the specified value

void array.Free();


Releases the dynamic array buffer and sets the zero dimension size to 0 (zero)

int array.Resize(const int range0_size, const int reserve);

int array.Resize(const int range_sizes[], const int reserve);


Sets a new size in the array first dimension

int array.Print();


Displays simple type array values in the journal

int array.Size(const int range=-1);

ArraySize, ArrayRange

Returns the number of elements in the entire array (range=-1) or in the specified array dimension

bool array.IsDynamic();


Checks if the array is dynamic

bool array.IsIndicatorBuffer();


Checks if the array is an indicator buffer

bool array.IsSeries();


Checks if the array is a timeseries

bool array.AsSeries();


Checks the array indexing direction

bool array.AsSeries(const bool as_series);


Sets the indexing direction in the array

int array.Copy(const src_array[], const int dst_start, const int src_start, const int cnt);


Copies array values to another array

int array.Compare(const src_array[], const int dst_start, const int src_start, const int cnt);


Returns the result of comparing two simple type arrays or custom structures

int array.Insert(const src_array[], const int dst_start, const int src_start, const int cnt);


Inserts the specified number of elements from a source array to a receiving one starting from a specified index

int array.Remove(const int start_pos, const int count);


Removes the specified number of elements from the array starting with a specified index

int array.Reverse(const int start_pos, const int count);


Reverses the specified number of elements in the array starting with a specified index

bool array.Swap(array& arr[]);


Exchanges the content with another dynamic array of the same type

void array.Sort(sort_function);


Sorts numeric arrays by the first dimension

int array.Search(scalar value, search_function);


Returns the index of the first element detected in the array first dimension

int array.Find((scalar value, search_function);


Performs a search in the array using the passed function and returns the index of the first detected element

array array.Select(scalar value, search_function);


Performs a search in the array using the passed function and returns the array with all detected elements


Access Specifiers

Access specifiers define how the compiler can access variables, members of structures or classes.

The const specifier declares a variable as a constant, and does not allow to change this variable during runtime. A single initialization of a variable is allowed when declaring it.


int OnCalculate (const int rates_total,      // size of the price[] array
                 const int prev_calculated,  // bars handled on a previous call
                 const int begin,            // where the significant data start from
                 const double& price[]       // array to calculate

To access members of structures and classes use the following qualifiers:

  • public – allows unrestricted access to the variable or class method
  • protected – allows access from methods of this class, as well as from methods of publicly inherited classes. Other access is impossible;
  • private – allows access to variables and class methods only from methods of the same class.
  • virtual – applies only to class methods (but not to methods of structures) and tells the compiler that this method should be placed in the table of virtual functions of the class.

Storage Classes

There are three storage classes: static, input and extern. These modifiers of a storage class explicitly indicate to the compiler that corresponding variables are distributed in a pre-allocated area of memory, which is called the global pool. Besides, these modifiers indicate the special processing of variable data. If a variable declared on a local level is not a static one, memory for such a variable is allocated automatically at a program stack. Freeing of memory allocated for a non-static array is also performed automatically when going beyond the visibility area of the block, in which the array is declared.

See also

Data Types, Encapsulation and Extensibility of Types,Initialization of Variables, Visibility Scope and Lifetime of Variables, Creating and Deleting Objects, Static Members of a Class