MetaTrader 5 herunterladen

ArrayCopy

Kopiert ein Array in das andere Array.

int  ArrayCopy(
   void&        dst_array[],         // Zielarray für Kopieren
   const void&  src_array[],         // Das Array von dem kopiert wird
   int          dst_start=0,         // Index, mit dem in Rezipienten geschrieben wird
   int          src_start=0,         // Index, mit dem Kopieren von der Quelle beginnt
   int          count=WHOLE_ARRAY    // Anzahl der Elemente
   );

Parameter

dst_array[]

[out]  Array-Rezipient.

src_array[]

[in] Ausgangs-Array.

dst_start=0

[in]  Anfangsindex für Array-Rezipienten. Standardwert des Anfangsindexes ist  - 0.

src_start=0

[in]  Anfangsindex für Ausgangs-Array. Standardwert des Anfangsindexes ist  - 0.

count=WHOLE_ARRAY

[in] Anzahl der Elemente für Kopieren. Als Voreinstellung wird das ganze Array kopiert. (count=WHOLE_ARRAY).

Rückgabewert

Gibt die Anzahl der kopierten Elemente zurück.

Hinweis

Wenn count<0 oder count>src_size-src_start, wird das Rest des Arrays kopiert. Arrays werden von links nach rechts kopiert. Für serielle Arrays wird die Anfangsposition unter Berücksichtigung des Kopierens von links nach rechts korrekt neubestimmt.

Wenn die Arrays verschiedener Typen angehören, wird beim Kopieren der Versuch, jedes Element des Ausgangsarrays zum Typ des Array-Rezipienten zu reduzieren. Ein Zeilenarray kann nur in ein Zeilenarray kopiert werden. Arrays der Klassen und Strukturen, die Objekte enthalten, die initialisiert werden müssen, werden nicht kopiert. Array der Strukturen kann nur ins Array desselben Typs kopiert werden.

Für dynamische Arrays mit Indexierung wie in Timeseries wird das Empfänger-Array automatisch bis die Menge der kopierenden Daten vergößert (wenn die Menge der kopierenden Daten größer als das Array ist). Empfängener-Array wird nicht automatisch verkleinert.

Beispiel:

#property description "Der Indikator hervorhebt die Kerzen, die lokal sind"
#property description "Maximum und Minimum. Die Länge des Intervalls für Aufsuchen"
#property description "die Extremums kann man durch die Eingabeparameters einstellt werden."
//--- Indikator Einstellungen
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
//---- plot
#property indicator_label1  "Extremums"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrLightSteelBlue,clrRed,clrBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- vordefinierte Konstante
#define INDICATOR_EMPTY_VALUE 0.0
//--- Eingabeparameters
input int InpNum=4; // Die Länge des Halb-Intervalls
// --- Indikator Puffers
double ExtOpen[];
double ExtHigh[];
double ExtLow[];
double ExtClose[];
double ExtColor[];
//--- globale Variablen
int    ExtStart=0; // der Index der ersten Kerze, die kein Extremum ist
int    ExtCount=0; // Anzahl der Kerzen, nicht den Extremums in diesen Intervall
//+------------------------------------------------------------------+
//| Zeichnen die Kerzen, nicht Extremums                             |
//+------------------------------------------------------------------+
void FillCandles(const double &open[],const double &high[],
                 const double &low[],const double &close[])
  {
//--- Zeichnen Sie die Kerzen
   ArrayCopy(ExtOpen,open,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtHigh,high,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtLow,low,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtClose,close,ExtStart,ExtStart,ExtCount);
 ;}
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Bindung von Array zum Indikator Puffer
   SetIndexBuffer(0,ExtOpen);
   SetIndexBuffer(1,ExtHigh);
   SetIndexBuffer(2,ExtLow);
   SetIndexBuffer(3,ExtClose);
   SetIndexBuffer(4,ExtColor,INDICATOR_COLOR_INDEX);
//--- erstellen Sie die Wert, die nicht sichtbar sein werden
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,INDICATOR_EMPTY_VALUE);
//--- erstellen Sie die Name von Indikator-Puffers für die Anzeige im Daten-Fenster
   PlotIndexSetString(0,PLOT_LABEL,"Open;High;Low;Close");
//---
   return(INIT_SUCCEEDED);
 ;}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- stellen Sie die gerade Richtung der Indexierung in Zeitreihen ein
   ArraySetAsSeries(open,false);
   ArraySetAsSeries(high,false);
   ArraySetAsSeries(low,false);
   ArraySetAsSeries(close,false);
//--- Variable zur Berechnung den Anfang des Bars
   int start=prev_calculated;
//--- für die ersten InpNum*2 Bars wird die Berechnung nicht durchgeführt
   if(start==0)
     {
      start+=InpNum*2;
      ExtStart=0;
      ExtCount=0;
    ;}
//--- Wenn sich nur eine Bar gebildet hat, so werden wir den nächsten potentiellen Extremum prüfen
   if(rates_total-start==1)
      start--;
//--- der Index der Bar, den wir auf Extremum prüfen werden
   int ext;
//--- die Zyklus von die Berechnung der Indikatorwerte
   for(int i=start;i<rates_total-1;i++)
     {
      //--- vornherein an der i-ten Bar ohne Zeichnung
      ExtOpen[i]=0;
      ExtHigh[i]=0;
      ExtLow[i]=0;
      ExtClose[i]=0;
      //--- der Extremum Index für die Überprüfung
      ext=i-InpNum;
      //--- die Überprüfung für das lokale Maximum
      if(IsMax(high,ext))
        {
         //--- bezeichnen Sie die Extremum Kerze
         ExtOpen[ext]=open[ext];
         ExtHigh[ext]=high[ext];
         ExtLow[ext]=low[ext];
         ExtClose[ext]=close[ext];
         ExtColor[ext]=1;
         //--- die übrigen Kerzen werden wir bis zu Extremum mit der neutralen Farbe bezeichnen
         FillCandles(open,high,low,close);
         //--- ändern Sie die Variablenwerte
         ExtStart=ext+1;
         ExtCount=0;
         //--- gehen Sie zum nächsten Iteration
         continue;
       ;}
      //--- Überprüfung für das lokale Minimum
      if(IsMin(low,ext))
        {
         //--- bezeichnen Sie die Extremum Kerze
         ExtOpen[ext]=open[ext];
         ExtHigh[ext]=high[ext];
         ExtLow[ext]=low[ext];
         ExtClose[ext]=close[ext];
         ExtColor[ext]=2;
         //--- die übrigen Kerzen werden wir bis zu Extremum mit der neutralen Farbe bezeichnen
         FillCandles(open,high,low,close);
         //--- ändern Sie die Variablenwerte
         ExtStart=ext+1;
         ExtCount=0;
         //--- gehen Sie zum nächsten Iteration
         continue;
       ;}
      // vergrößern Sie die Anzahl nicht den Extremums in diesem Intervall
      ExtCount++;
    ;}
//--- den Wert prev_calculated für den nächsten Anruf zurückgeben
   return(rates_total);
 ;}
//+------------------------------------------------------------------+
//| Ob das aktuelle Element des Arrays ein lokales Maximum ist       |
//+------------------------------------------------------------------+
bool IsMax(const double &price[],const int ind)
  {
//--- Variable von dem Intervall-Anfang
   int i=ind-InpNum;
//--- Variable von dem Intervall-Abschluß
   int finish=ind+InpNum+1;
//--- die Überprüfung für die erste Hälfte des Intervalls
   for(;i<ind;i++)
     {
      if(price[ind]<=price[i])
         return(false);
    ;}
//--- die Überprüfung für die zweite Hälfte des Intervalls
   for(i=ind+1;i<finish;i++)
     {
      if(price[ind]<=price[i])
         return(false);
    ;}
//--- es ist Extremum
   return(true);
 ;}
//+------------------------------------------------------------------+
//| Ob das aktuell Element des Arrays ein lokales Minimum ist        |
//+------------------------------------------------------------------+
bool IsMin(const double &price[],const int ind)
  {
//--- Variable von dem Intervall-Anfang
   int i=ind-InpNum;
//--- Variable von dem Intervall-Abschluß
   int finish=ind+InpNum+1;
//--- die Überprüfung für die erste Hälfte des Intervalls
   for(;i<ind;i++)
     {
      if(price[ind]>=price[i])
         return(false);
    ;}
//--- die Überprüfung für die zweite Hälfte des Intervalls
   for(i=ind+1;i<finish;i++)
     {
      if(price[ind]>=price[i])
         return(false);
    ;}
//--- es ist Extremum
   return(true);
 ;}