Variablen

Erklaerung der Variablen

Variablen muessen vor der Vewendung erklärt werden. Für die Identifizierung der Variablen werden unikale Namen verwendet. Beschreibungen der Variablen werden für ihre Definition und Typenerklärung verwendet. Beschreibung ist keine Anweisung.

Einfache Typen sind:

  • char, short, int, long, uchar, ushort, uint, ulong – Ganzzahlen;
  • color – Ganzzahl, repraesentiert RGB-Farbe;
  • datetime – Datum und Zeit, zeichenlose Ganzzahl, enthaehlt Sekundenzahl, die seit  0 Uhr 1 Januar 1970 vergangen sind;
  • bool – logische Werte true und false;
  • double – Zahlen doppelter Genauigkeit mit Fliesspunkt;
  • float –Zahlen mit einfacher Genauigkeit  mit Fliesspunkt;
  • string – Symbolzeilen.

Beispiele:

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

 

Zusammengesetzte Typen:

Strukturen – sind zusammengesetzte Datentypen, gebildet mit Verwendung von anderen Typen.

struct MyTime
  {
   int hour;    // 0-23
   int minute;  // 0-59
   int second;  // 0-59
  };
...
MyTime strTime; // Variable des Typs der früher erklärten Struktur MyTime

Vor der Strukturerklärung kann man nicht Variablen des Typs Strukturen erklären.

Array

Array - indizierte Menge gleichartiger  Daten:

int    a[50];       // eindimensionales Feld aus 50 Ganzzahlen.
double m[7][50];    // zweidimensionales Feld aus sieben Feldern,
                    // jedes von denen aus 50 Zahlen besteht.
MyTime t[100];      // Feld mit den Elementen der Art MyTime

 

Arrayindex kann nur Ganzzahl sein. Es werden nicht mehr als vierdimensionale Arrays zugelassen. Die Nummerierung der Elemente des Arrays faengt mit Null an. Das letzte Element des eindimensionalen Arrays ist um eine Nummer kleiner, als die Feldgroesse, d.h. der Zugriff zum  letzten Element des Arrays aus 50 Ganzzahlen wird als  a[49] aussehen. Dasselbe bezieht sich auf vieldimensionale Arrays - Indizieren einer Dimension erfolgt von 0 bis -1. Das letzte Element des zweidimensionalen Arrays aus dem Beispiel wird als m[6][49] aussehen.

Statistische Arrays können nicht als Timeserien dargestellt werden, d.h. die Funktion ArraySetAsSeries(), die den Zugang zu Feldelementen vom Ende zum Anfang des Arrays festlegt, ist für sie nicht anwendbar. Wenn es notwendig ist, den Zugang zum Feld in Timeserien zu gewaehrleisten, benutzen Sie   Objekt des dynamischen Arrays.

Beim Zugriff ueber die Grenzen des Arrays hinaus generiert das vollziehende System ein kritisches Fehler und die Durchführung des Programms wird unterbrochen.

Integrierte Methoden für die Arbeit mit Arrays #

Die Funktionen aus dem Abschnitt Array-Funktionen, sowie die integrierten Methoden können verwendet werden, um mit Arrays zu arbeiten:

Methode

Äquivalente

Beschreibung

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

ArrayFill, ArrayInitialize.

Füllt das Array mit dem angegebenen Wert.

void array.Free();

ArrayFree

Gibt den dynamischen Array-Puffer frei und setzt die Größe der Null-Dimension auf 0 (Null).

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

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

ArrayResize

Legt eine neue Größe in der ersten Dimension des Arrays fest.

int array.Print();

ArrayPrint

Druckt die Werte des Arrays mit einfachen Typen im Journal aus.

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

ArraySize, ArrayRange

Gibt die Anzahl der Elemente des gesamten Arrays (range=-1) oder der angegebenen Array-Dimension zurück.

bool array.IsDynamic();

ArrayIsDynamic

Prüft, ob das Array dynamisch ist.

bool array.IsIndicatorBuffer();

 

Prüft, ob das Array ein Indikatorpuffer ist.

bool array.IsSeries();

ArrayIsSeries

Prüft, ob das Array eine Zeitreihe ist.

bool array.AsSeries();

ArrayGetAsSeries

Prüft die Indexrichtung des Arrays.

bool array.AsSeries(const bool as_series);

ArraySetAsSeries

Legt die Indexrichtung im Array fest.

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

ArrayCopy

Kopiert die Array-Werte in ein anderes Array.

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

ArrayCompare

Gibt das Ergebnis des Vergleichs zweier einfacher Arrays oder nutzerdefinierter Strukturen zurück.

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

ArrayInsert

Fügt die angegebene Anzahl von Elementen aus einem Quell-Array in ein Empfangs-Array ein, beginnend mit einem angegebenen Index.

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

ArrayRemove

Entfernt die angegebene Anzahl von Elementen aus dem Array, beginnend mit einem angegebenen Index.

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

ArrayReverse

Kehrt die angegebene Anzahl von Elementen im Array um, beginnend mit einem angegebenen Index.

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

ArraySwap

Tauscht den Inhalt mit einem anderen dynamischen Array desselben Typs.

void array.Sort(sort_function);

ArraySort

Sortiert numerische Arrays nach der ersten Dimension.

int array.Search(scalar value, search_function);

ArrayBsearch

Gibt den Index des ersten gefundenen Elements der ersten Dimension des Arrays zurück.

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

 

Führt eine Suche im Array mit der übergebenen Funktion durch und gibt den Index des ersten gefundenen Elements zurück.

array array.Select(scalar value, search_function);

 

Führt eine Suche im Array mit der übergebenen Funktion durch und gibt das Array mit allen gefundenen Elementen zurück.

 

Zugangsspezifikatoren

Zugangsspezifikatoren deuten dem Compilierer darauf, wie der Zugang zu Variable, Struktur- und Klassen-gliedern durchgeführt werden kann.

Spezifikator const erklärt die Variable als Konstante und erlaubt nicht den Wert dieser Variable bei der Programmdurchführung zu verändern. Es wird eimalige Initialisierung der Variable bei ihrer Erklaerung zugelassen.

Beispiel

int OnCalculate (const int rates_total,      // Feldgroesse price[]
                 const int prev_calculated,  // Anzahl der verarbeiteter Bars im vorigen Aufruf 
                 const int begin,            // Anfangsposition der bedeutsamen Daten 
                 const double& price[]       // Feld für Berechnung
   );

für Zugang zu Struktur- und Klassenglieder werden folgende Spezifikatoren verwendet:

  • public – erlaubt unbegrenzten Zugang zur Variable oder Klassenmethoden;
  • protected – erlaubt Zugang seitens Methoden der vorliegenden Klasse und seitens Methoden der oeffentlich heritierten Klassen. Anderer Zugang ist unmoeglich;
  • private – ermöglicht Zugang zu Variablen und Klassenmethoden ausschliesslich aus Metoden der vorliegenden Klasse.
  • virtual – nur für Klassenmethoden anwendbar (nicht aber für Strukturmethoden) und meldet dem Compilierer an, dass diese Metode in der Tabelle virtueller Klassenfunktionen aufgestellt werden muss.

Speicherklassen

Es gibt drei Speicherklassen: static, input und extern. Diese Modifikatoren der Speicherklasse deuten dem Compilierer darauf, dass entsprechende Variablen im vorbestimmten Speicherplatz eingeordnet werden, der als globaler Pool bezeichnet wird. Dabei deuten diese Modifikatoren auf besondere Bearbeitung dieser Variablen hin.

Wenn eine Variable, die auf dem lokalen Niveau erklärt wurde, nicht statisch ist, erfolgt Speicherverteilung für diese Variable automatisch auf dem Programmstack. Speicher, der nicht für ein statisches Feld verteilt wurde, erfolgt auch automatisch beim Ausgang vom Sichtbarkeitsbeich des Blocks, in dem das Feld erklärt wurde.

Sehen Sie auch

Datentypen, Inkapsulation und Erweiterungsfaehigkeit der Typen, Initialisierung der Variablen, Sichtbereich und Lebensdauer der Variablen, Erzeugung und Entfernung der Objekte, Statische Klassenmitglieder