Yeni Başlayanlar için MQL5: Uzman Danışmanlarda Teknik Göstergeleri Kullanma Rehberi
MetaTrader 5
—
Göstergeler
| 9 Aralık 2021, 10:22
168
0
Giriş
Kodunda standart teknik göstergeleri kullanmayan bir Uzman Danışman veya gösterge nadir bulunur. Hem yeni başlayanlar hem de ileri düzey alım satım stratejisi geliştiricileri için popülerdir. Gösterge oluşturmanın ayrıntılarını anlamak zor değildir; bu makalenin amacı bu konuda size yardımcı olmaktır. Yerleşik standart teknik göstergelerle çalışmak için fonksiyonların kullanımını ele alacağız.
Standart Teknik Göstergelerin Fonksiyonlarını Kullanmanın Temelleri
Çağrıldığında, teknik göstergenin her fonksiyonu, belirtilen giriş parametreleriyle oluşturulan nesnenin (göstergenin örneği) bir tanıtıcı değerini oluşturur. Tanıtıcı değerin amacı, onu bu nesneyle atamaktır. Gösterge arabelleğinden verileri alıp kendi hesaplamalarınızda kullanmanız yeterli olacaktır. Şu örneği düşünün:
double MA[]; // array for the indicator iMA int MA_handle; // handle of the indicator iMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array MA[] with current values of iMA //--- Copying 100 elements CopyBuffer(MA_handle,0,0,100,MA); //--- set indexing of elements as series, as in MQL4 ArraySetAsSeries(MA,true); //--- here you can use the data of MA[] as you wish, for example: if(MA[0]>MA[1]) { //--- some operations } }
Gördüğümüz gibi, her şey oldukça basit. Bu örnek, yatırımcılar arasında çok popüler olan iMA göstergesinin nasıl kullanılacağını gösterir.
Göstergenin tanıtıcı değeri OnInit() fonksiyonu içinde oluşturulmalıdır.
- "Öğelerin indislemesini MQL4'teki gibi seri olarak ayarla" ifadesi ne anlama geliyor? Örneğimizde indisleme öğelerini timeseries olarak kullandık. Başka bir deyişle, mevcut çubuk (henüz oluşmamış) her zaman [0] indisine, önceki ise (zaten oluşturulmuş olan) indis [1]'e sahiptir vs.
- Neden indisleme ayarı yaparız? Bunu algoritmanın rahatlığı ve optimum şekilde uygulanması için kullandık. MQL5 dili, programcı için uygun indislemenin kullanılmasını sağlar.
- OnInit() fonksiyonu içinde bir gösterge oluşturmak neden daha iyidir? Tabii ki, programın herhangi bir yerinde oluşturulabilir, çünkü açık bir yasak yoktur. Bununla birlikte, önerilen yöntem lehine güçlü bir argüman vardır: OnInit() fonksiyonu, bir Uzman Danışmanın başlangıcında bir kez çağrılır ve yürütme sırasında parametrelerini değiştirmeyen göstergelerin başlatılmasını gerçekleştirmek için oldukça yeterlidir. Giriş parametrelerini değiştirmeleri durumunda, onları başka bir fonksiyon içinde, örneğin OnTick() fonksiyonunda tekrar başlatmak mümkündür.
Programlama dersleri
Hemen hemen her Uzman Danışman, alım satım işlemlerini yalnızca demoda değil, aynı zamanda gerçek bir hesapta da gerçekleştirmek üzere tasarlanmıştır. Alım satım yapılırken sessizce uyumak istiyorsanız, alım satımın olası tüm sonuçlarını öngörmelisiniz. Yüksek nitelikli otomatik alım satım sistemi geliştiricileri bile genellikle can sıkıcı hatalar yapar. Böyle bir hatanın bedeli çok yüksek olabilir!
Mesela, Automated Trading Championship 2008'de gerçekleşen bir hikayeden bahsedelim. Katılımcılardan birinin Uzman Danışman mevduatını belli bir seviyeye çıkarmalı ve uykuya geçmelidir. Bu gerçekleşmiştir. Yazar ve Uzman Danışman'ın çalışmalarını izleyen herkes, uyandığında tekrar alım satıma başlayıp kazanılan parayı kaybettiğinde şaşkınlığa uğradı.
Elbette robot kontrolden çıktığında benzer hataları yapmak istemezsiniz. Öyleyse standart teknik göstergeleri kullanırken yakalanabilecek "tehlikeleri" ele alalım:
- Nesne işaretçisi, başlatma bloğunda oluşturulur. Peki ya başarısız olursa? Bu durumda boş bir referans alırız. Bu nedenle, MQL5 geliştiricileri tarafından sağlanan geçerliliği kontrol etme imkanını kullanalım. İşaretçi oluşturulmamışsa, fonksiyon tarafından döndürülen tanıtıcı değeri, INVALID_HANDLE = -1 standart sabitine eşit olacaktır.
- Göstergeden veri aldığımızda onun değerlerini göstergenin arabelleğine kopyalıyor ve hesaplamalarımızda kullanıyoruz. Ya başarısız olursa? Kopyalama başarısız olursa, bir alım satım sistemi yanlış alım satım sinyalleri üretebilir. Bu gibi durumlar için, MQL5 geliştiricileri, kopyalanan öğelerin sayısını anında kontrol etme olanağı sağlamıştır. Hata durumunda kopyalanan öğelerin sayısı -1'e eşit olacaktır.
Şimdi nasıl kodlanabileceğini düşünelim:
//---- arrays for indicators double MA[]; // array for the indicator iMA //---- handles for indicators int MA_handle; // handle of the indicator iMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); //--- report if there was an error in object creation if(MA_handle<0) { Print("The creation of iMA has failed: MA_handle=",INVALID_HANDLE); Print("Runtime error = ",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array MA[] with current values of iMA //--- 100 elements should be written to the array //--- if there was an error, we terminate the execution of program if(CopyBuffer(MA_handle,0,0,100,MA)<=0) return; //--- set indexation of array MA[] as timeseries ArraySetAsSeries(MA,true); //--- here you can use the data of MA[] as you wish if(MA[0]>MA[1]) { //--- some operations } }
Koddaki sadece küçük bir değişikliğin güvenliği ve güvenilirliği artırdığını unutmayın. Ancak, hepsi bu kadar değil. Şimdi göstergenin değerlerinin diziye kopyalanması prosedürü iyileştirilebilir; yazılan fonksiyonu kullanmak gerekir:
//+------------------------------------------------------------------------------+ //| The function copies the values of the indicator,the elements | //| will be indexed depending on the value of the input parameter asSeries | //+------------------------------------------------------------------------------+ bool CopyBufferAsSeries( int handle, // indicator's handle int bufer, // buffer index int start, // start index int number, // number of elements to copy bool asSeries, // if it's true, the elements will be indexed as series double &M[] // target array ) { //--- filling the array M with current values of the indicator if(CopyBuffer(handle,bufer,start,number,M)<=0) return(false); //--- the elements will be indexed as follows: //--- if asSeries=true, it will be indexed as timeseries //--- if asSeries=false, it will be indexed as default ArraySetAsSeries(M,asSeries); //--- return(true); }
CopyBufferAsSeries fonksiyonu makaleye eklenen GetIndicatorBuffers.mqh dosyasında bulunur. Kullanımı için kodumuza include yönergesini eklemeliyiz. Bunu ..\ MQL5\Include\ klasörüne kopyalamak gerekir. iMA göstergesini çağıran ve göstergenin arabelleğinden ilgili diziye verileri kopyalayan son kod aşağıdaki gibi görünür:
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double MA[]; // array for the indicator iMA //---- handles for indicators int MA_handle; // handle for the indicator iMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); //--- report if there was an error in object creation if(MA_handle<0) { Print("The creation of iMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array MA[] with current values of iMA //--- set indexation of array MA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return; //--- here you can use the data of MA[] as you wish, for example: if(MA[0]>MA[1]) { //--- some operations } }
Çoklu Arabellek Göstergelerinin Özellikleri
Örnek olarak, 3 gösterge arabelleğine sahip olan iAlligator göstergesini ele alalım:
- 0 ara bellek - GATORJAW_LINE
- 1. arabellek - GATORTEETH_LINE
- 2. arabellek - GATORLIPS_LINE
Bu göstergelerin arabelleğinden alınan verileri tek bir çağrı kullanarak yürütmek için, makaleye eklenmiş olan dosyada bulunan fonksiyonu kullanacağız;
//+------------------------------------------------------------------------------+ //| The function copies the values of the indicator Alligator to three arrays: | //| Jaws[], Teeth[], Lips[] (with elements indexed as timeaseries). | //+------------------------------------------------------------------------------+ bool GetAlligatorBuffers(int Alligator_handle, int start, int number, double &Jaws[], double &Teeth[], double &Lips[], bool asSeries=true // (elements indexed as timeaseries) ) { //--- filling an array Jaws with current values of GATORJAW_LINE if(!CopyBufferAsSeries(Alligator_handle,0,start,number,asSeries,Jaws)) return(false); //--- filling an array Teeth with current values of GATORTEETH_LINE if(!CopyBufferAsSeries(Alligator_handle,1,start,number,asSeries,Teeth)) return(false); //--- filling an array Lisp with current values of GATORLIPS_LINE if(!CopyBufferAsSeries(Alligator_handle,2,start,number,asSeries,Lips)) return(false); //--- return(true); }
fonksiyon aşağıdaki gibi kullanılabilir:
#include <GetIndicatorBuffers.mqh> //---- indicator buffers double Jaws[]; // array for GATORJAW_LINE of iAlligator double Teeth[]; // array for GATORTEETH_LINE of iAlligator double Lips[]; // array for GATORLIPS_LINE of iAlligator //---- handles for indicators int Alligator_handle; // handle of the indicator iAlligator //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iAlligator Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN); //--- report if there was an error in object creation if(Alligator_handle<0) { Print("The creation of iAlligator has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- fill arrays with current values of Alligator //--- return if there was an error if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return; }
Anahtar noktaları ana hatlarıyla belirledik, şimdi tüm standart göstergeler için örnekleri değerlendirmeye hazırız.
Standart Göstergelerin Kullanım Örnekleri
iAC
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double AC[]; // array for the indicator iAC //---- handles for indicators int AC_handle; // handle of the indicator iAC //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iAC AC_handle=iAC(NULL,0); //--- report if there was an error in object creation if(AC_handle<0) { Print("The creation of iAC has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array AC[] with current values of iAC //--- set indexation of array AC[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(AC_handle,0,0,100,true,AC)) return; }
iAD
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double AD[]; // array for the indicator iAD //---- handles for indicators int AD_handle; // handle for the indicator iAD //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iAD AD_handle=iAD(NULL,0,VOLUME_TICK); //--- report if there was an error in object creation if(AD_handle<0) { Print("The creation of iAD has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array AD[] with current values of iAD //--- set indexation of array AD[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(AD_handle,0,0,100,true,AD)) return; }
iADX
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Main[]; // array for MAIN_LINE of iADX double PlusDI[]; // array for PLUSDI_LINE of iADX double MinusDI[]; // array for MINUSDI_LINE of iADX //---- handles for indicators int ADX_handle; // handle of the indicator iADX //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iADX ADX_handle=iADX(NULL,0,14); //--- report if there was an error in object creation if(ADX_handle<0) { Print("The creation of iADX has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetADXBuffers(ADX_handle,0,100,Main,PlusDI,MinusDI,true)) return; }
iADXWilder
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Main[]; // array for MAIN_LINE of iADXWilder double PlusDI[]; // array for PLUSDI_LINE of iADXWilder double MinusDI[]; // array for MINUSDI_LINE of iADXWilder //---- handles for indicators int ADXWilder_handle; // handle of the indicator iADXWilder //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iADXWilder ADXWilder_handle=iADXWilder(NULL,0,14); //--- report if there was an error in object creation if(ADXWilder_handle<0) { Print("The creation of iADXWilder has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetADXWilderBuffers(ADXWilder_handle,0,100,Main,PlusDI,MinusDI,true)) return; }
iAlligator
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Jaws[]; // array for GATORJAW_LINE of iAlligator double Teeth[]; // array for GATORTEETH_LINE of iAlligator double Lips[]; // array for GATORLIPS_LINE of iAlligator //---- handles for indicators int Alligator_handle; // handle of the indicator iAlligator //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iAlligator Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN); //--- report if there was an error in object creation if(Alligator_handle<0) { Print("The creation of iAlligator has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return; }
iAMA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double AMA[]; // array for the indicator iAMA //---- handles for indicators int AMA_handle; // handle for the indicator iAMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iAMA AMA_handle=iAMA(NULL,0,21,5,8,0,PRICE_CLOSE); //--- report if there was an error in object creation if(AMA_handle<0) { Print("The creation of iAMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array AMA[] with current values of iAMA //--- set indexation of array AMA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(AMA_handle,0,0,100,true,AMA)) return; }
iAO
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double AO[]; // array for the indicator iAO //---- handles for indicators int AO_handle; // handle of the indicator iAO //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iAO AO_handle=iAO(NULL,0); //--- report if there was an error in object creation if(AO_handle<0) { Print("The creation of iAO has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array AO[] with current values of iAO //--- set indexation of array AO[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(AO_handle,0,0,100,true,AO)) return; }
iATR
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double ATR[]; // array for the indicator iATR //---- handles for indicators int ATR_handle; // handle of the indicator iATR //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iATR ATR_handle=iATR(NULL,0,14); //--- report if there was an error in object creation if(ATR_handle<0) { Print("The creation of iATR has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array ATR[] with current values of iATR //--- set indexation of array ATR[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(ATR_handle,0,0,100,true,ATR)) return; }
iBearsPower
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double BearsPower[]; // array for the indicator iBearsPower //---- handles for indicators int BearsPower_handle; // handle for the indicator iBearsPower //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iBearsPower BearsPower_handle=iBearsPower(NULL,0,14); //--- report if there was an error in object creation if(BearsPower_handle<0) { Print("The creation of iBearsPower has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array BearsPower[] with current values of iBearsPower //--- set indexation of array BearsPower[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(BearsPower_handle,0,0,100,true,BearsPower)) return; }
iBands
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Base[]; // array for BASE_LINE of iBands double Upper[]; // array for UPPER_BAND of iBands double Lower[]; // array for LOWER_BAND of iBands //---- handles for indicators int Bands_handle; // handle of the indicator iBands //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iBands Bands_handle=iBands(NULL,0,144,0,2,PRICE_CLOSE); //--- report if there was an error in object creation if(Bands_handle<0) { Print("The creation of iBands has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetBandsBuffers(Bands_handle,0,100,Base,Upper,Lower,true)) return; }
iBullsPower
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double BullsPower[]; // array for the indicator iBullsPower //---- handles for indicators int BullsPower_handle; // handle for the indicatoriBullsPower //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iBullsPower BullsPower_handle=iBullsPower(NULL,0,14); //--- report if there was an error in object creation if(BullsPower_handle<0) { Print("The creation of iBullsPower has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array BullsPower[] with current values of iBullsPower //--- set indexation of array BullsPower[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(BullsPower_handle,0,0,100,true,BullsPower)) return; }
iCCI
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double CCI[]; // array for the indicator iCCI //---- handles for indicators int CCI_handle; // handle for the indicator iCCI //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iCCI CCI_handle=iCCI(NULL,0,14,PRICE_CLOSE); //--- report if there was an error in object creation if(CCI_handle<0) { Print("The creation of iCCI has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array CCI[] with current values of iCCI //--- set indexation of array CCI[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(CCI_handle,0,0,100,true,CCI)) return; }
iChaikin
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Chaikin[]; // array for the indicator iChaikin //---- handles for indicators int Chaikin_handle; // handle for the indicator iChaikin //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iChaikin Chaikin_handle=iChaikin(NULL,0,8,14,MODE_EMA,VOLUME_TICK); //--- report if there was an error in object creation if(Chaikin_handle<0) { Print("The creation of iChaikin has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array Chaikin[] with current values of iChaikin //--- set indexation of array AC[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(Chaikin_handle,0,0,100,true,Chaikin)) return; }
iDEMA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double DEMA[]; // array for the indicator iDEMA //---- handles for indicators int DEMA_handle; // handle for the indicator iDEMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iDEMA DEMA_handle=iDEMA(NULL,0,8,0,PRICE_CLOSE); //--- report if there was an error in object creation if(DEMA_handle<0) { Print("The creation of iDEMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array DEMA[] with current values of iDEMA //--- set indexation of array DEMA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(DEMA_handle,0,0,100,true,DEMA)) return; }
iDeMarker
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double DeMarker[]; // array for the indicator iDeMarker //---- handles for indicators int DeMarker_handle; // handle for the indicator iDeMarker //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iDeMarker DeMarker_handle=iDeMarker(NULL,0,21); //--- report if there was an error in object creation if(DeMarker_handle<0) { Print("The creation of iDeMarker has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array DeMarker[] with current values of iDeMarker //--- set indexation of array DeMarker[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(DeMarker_handle,0,0,100,true,DeMarker)) return; }
iEnvelopes
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Upper[]; // array for UPPER_LINE of iEnvelopes double Lower[]; // array for LOWER_LINE of iEnvelopes //---- handles for indicators int Envelopes_handle; // handle of the indicator iEnvelopes //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iEnvelopes Envelopes_handle=iEnvelopes(NULL,0,14,0,MODE_SMA,PRICE_CLOSE,0.1); //--- report if there was an error in object creation if(Envelopes_handle<0) { Print("The creation of iEnvelopes has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation for arrays as timeseries //--- return if there was an error //--- filling the arrays with current values of iEnvelopes if(!GetEnvelopesBuffers(Envelopes_handle,0,100,Upper,Lower,true)) return; }
iForce
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Force[]; // array for the indicator iForce //---- handles for indicators int Force_handle; // handle for the indicator iForce //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iForce Force_handle=iForce(NULL,0,21,MODE_SMA,VOLUME_TICK); //--- report if there was an error in object creation if(Force_handle<0) { Print("The creation of iForce has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array Force[] with current values of iForce //--- set indexation of array Force[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(Force_handle,0,0,100,true,Force)) return; }
iFractals
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Upper[]; // array for UPPER_LINE of iFractals double Lower[]; // array for LOWER_LINE of iFractals //---- handles for indicators int Fractals_handle; // handle of the indicator iFractals //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iFractals Fractals_handle=iFractals(NULL,0); //--- report if there was an error in object creation if(Fractals_handle<0) { Print("The creation of iFractals has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetFractalsBuffers(Fractals_handle,0,100,Upper,Lower,true)) return; }
iFrAMA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double FrAMA[]; // array for the indicator iFrAMA //---- handles for indicators int FrAMA_handle; // handle for the indicator iFrAMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iFrAMA FrAMA_handle=iFrAMA(NULL,0,21,0,MODE_SMA); //--- report if there was an error in object creation if(FrAMA_handle<0) { Print("The creation of iFrAMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array FrAMA[] with current values of iFrAMA //--- set indexation of array FrAMA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(FrAMA_handle,0,0,100,true,FrAMA)) return; }
iGator
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Upper[]; // array for UPPER_LINE of iGator double Lower[]; // array for LOWER_LINE of iGator //---- handles for indicators int Gator_handle; // handle of the indicator iGator //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iGator Gator_handle=iGator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN); //--- report if there was an error in object creation if(Gator_handle<0) { Print("The creation of iGator has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetGatorBuffers(Gator_handle,0,100,Upper,Lower,true)) return; }
iIchimoku
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Tenkansen[]; // array for TENKANSEN_LINE of iIchimoku double Kijunsen[]; // array for KIJUNSEN_LINE of iIchimoku double SenkouspanA[]; // array for SENKOUSPANA_LINE of iIchimoku double SenkouspanB[]; // array for SENKOUSPANB_LINE of iIchimoku double Chinkouspan[]; // array for CHINKOUSPAN_LINE of iIchimoku //---- handles for indicators int Ichimoku_handle; // handle of the indicator iIchimoku //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iIchimoku Ichimoku_handle=iIchimoku(NULL,0,9,26,52); //--- report if there was an error in object creation if(Ichimoku_handle<0) { Print("The creation of iIchimoku has failed: Runtime error =",GetLastError()); //--- forced program terminatio return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetIchimokuBuffers(Ichimoku_handle,0,100, Tenkansen, Kijunsen, SenkouspanA, SenkouspanB, Chinkouspan, true)) return; }
iBWMFI
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double BWMFI[]; // array for the indicator iBWMFI //---- handles for indicators int BWMFI_handle; // handle of the indicato iBWMFI //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iBWMFI BWMFI_handle=iBWMFI(NULL,0,VOLUME_TICK); //--- report if there was an error in object creation if(BWMFI_handle<0) { Print("The creation of iBWMFI has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array BWMFI[] with current values of iBWMFI //--- set indexation of array BWMFI[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(BWMFI_handle,0,0,100,true,BWMFI)) return; }
iMomentum
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Momentum[]; // array for the indicator iMomentum //---- handles for indicators int Momentum_handle; // handle for the indicator iMomentum //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMomentum Momentum_handle=iMomentum(NULL,0,14,PRICE_CLOSE); //--- report if there was an error in object creation if(Momentum_handle<0) { Print("The creation of iMomentum has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array Momentum[] with current values of iMomentum //--- set indexation of array Momentum[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(Momentum_handle,0,0,100,true,Momentum)) return; }
iMFI
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double MFI[]; // array for the indicator iMFI //---- handles for indicators int MFI_handle; // handle of the indicator iMFI //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMFI MFI_handle=iMFI(NULL,0,14,VOLUME_TICK); //--- report if there was an error in object creation if(MFI_handle<0) { Print("The creation of iMFI has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array MFI[] with current values of iMFI //--- set indexation of array MFI[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(MFI_handle,0,0,100,true,MFI)) return; }
iMA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double MA[]; // array for the indicator iMA //---- handles for indicators int MA_handle; // handle of the indicator iMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); //--- report if there was an error in object creation if(MA_handle<0) { Print("The creation of iMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array MA[] with current values of iMA //--- set indexation of array MA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return; }
iOsMA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double OsMA[]; // array for the indicator iOsMA //---- handles for indicators int OsMA_handle; // handle of the indicator iOsMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iOsMA OsMA_handle=iOsMA(NULL,0,8,21,14,PRICE_MEDIAN); //--- report if there was an error in object creation if(OsMA_handle<0) { Print("The creation of iOsMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array OsMA[] with current values of iOsMA //--- set indexation of array OsMA[] timeseries //--- return if there was an error if(!CopyBufferAsSeries(OsMA_handle,0,0,100,true,OsMA)) return; }
iMACD
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Main[]; // array for MAIN_LINE of iMACD double Signal[]; // array for SIGNAL_LINE of iMACD //---- handles for indicators int MACD_handle; // handle of the indicator iMACD //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iMACD MACD_handle=iMACD(NULL,0,12,26,9,PRICE_CLOSE); //--- report if there was an error in object creation if(MACD_handle<0) { Print("The creation of iMACD has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetMACDBuffers(MACD_handle,0,100,Main,Signal,true)) return; }
iOBV
#include <GetIndicatorBuffers.mqh> //---- indicator buffers double OBV[]; // array for the indicator iOBV //---- handles for indicators int OBV_handle; // handle for the indicator iOBV //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iOBV OBV_handle=iOBV(NULL,0,VOLUME_TICK); //--- report if there was an error in object creation if(OBV_handle<0) { Print("The creation of iOBV has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array OBV[] with current values of iOBV //--- set indexation of array AC[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(OBV_handle,0,0,100,true,OBV)) return; }
iSAR
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double SAR[]; // array for the indicator iSAR //---- handles for indicators int SAR_handle; // handle of the indicator iSAR //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iSAR SAR_handle=iSAR(NULL,0,0.02,0.2); //--- report if there was an error in object creation if(SAR_handle<0) { Print("The creation of iSAR has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array SAR[] with current values of iSAR //--- set indexation of array SAR[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(SAR_handle,0,0,100,true,SAR)) return; }
iRSI
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double RSI[]; // array for the indicator iRSI //---- handles for indicators int RSI_handle; // handle of the indicator iRSI //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iRSI RSI_handle=iRSI(NULL,0,21,PRICE_CLOSE); //--- report if there was an error in object creation if(RSI_handle<0) { Print("The creation of iRSI has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array RSI[] with current values of iRSI //--- set indexation of array RSI[] as timeserie //--- return if there was an error if(!CopyBufferAsSeries(RSI_handle,0,0,100,true,RSI)) return; }
iRVI
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Main[]; // array for MAIN_LINE of iRVI double Signal[]; // array for SIGNAL_LINE of iRVI //---- handles for indicators int RVI_handle; // handle of the indicator iRVI //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iRVI RVI_handle=iRVI(NULL,0,14); //--- report if there was an error in object creation if(RVI_handle<0) { Print("The creation of iRVI has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetRVIBuffers(RVI_handle,0,100,Main,Signal,true)) return; }
iStdDev
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double StdDev[]; // array for the indicator iStdDev //---- handles for indicators int StdDev_handle; // handle for the indicator iStdDev //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iStdDev StdDev_handle=iStdDev(NULL,0,20,0,MODE_SMA,PRICE_CLOSE); //--- report if there was an error in object creation if(StdDev_handle<0) { Print("The creation of iStdDev has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array StdDev[] with current values of iStdDev //--- set indexation of array StdDev[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(StdDev_handle,0,0,100,true,StdDev)) return; }
iStochastic
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Main[]; // array for MAIN_LINE of iStochastic double Signal[]; // array for SIGNAL_LINE of iStochastic //---- handles for indicators int Stochastic_handle; // handle of the indicator iStochastic //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iStochastic Stochastic_handle=iStochastic(NULL,0,5,3,3,MODE_SMA,STO_LOWHIGH); //--- report if there was an error in object creation if(Stochastic_handle<0) { Print("The creation of iStochastic has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- set indexation of arrays as timeseries //--- filling the arrays with current values of all indicator's buffers //--- return if there was an error if(!GetStochasticBuffers(Stochastic_handle,0,100,Main,Signal,true)) return; }
iTEMA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double TEMA[]; // array for the indicator iTEMA //---- handles for indicators int TEMA_handle; // handle of the indicator iTEMA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iTEMA TEMA_handle=iTEMA(NULL,0,20,0,PRICE_CLOSE); //--- report if there was an error in object creation if(TEMA_handle<0) { Print("The creation of iTEMA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array TEMA[] with current values of iTEMA //--- set indexation of array TEMA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(TEMA_handle,0,0,100,true,TEMA)) return; }
iTriX
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double TriX[]; // array for the indicator iTriX //---- handles for indicators int TriX_handle; // handle of the indicator iTriX //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iTriX TriX_handle=iTriX(NULL,0,20,PRICE_CLOSE); //--- report if there was an error in object creation if(TriX_handle<0) { Print("The creation of iTriX has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array TriX[] with current values of iTriX //--- set indexation of array TriX[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(TriX_handle,0,0,100,true,TriX)) return; }
iWPR
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double WPR[]; // array for the indicator iWPR //---- handles for indicators int WPR_handle; // handle of the indicator iWPR //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iWPR WPR_handle=iWPR(NULL,0,14); //--- report if there was an error in object creation if(WPR_handle<0) { Print("The creation of iWPR has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array WPR[] with current values of iWPR //--- set indexation of array WPR[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(WPR_handle,0,0,100,true,WPR)) return; }
iVIDyA
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double VIDyA[]; // array for the indicator iVIDyA //---- handles for indicators int VIDyA_handle; // handle of the indicator iVIDyA //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iVIDyA VIDyA_handle=iVIDyA(NULL,0,14,21,0,PRICE_MEDIAN); //--- report if there was an error in object creation if(VIDyA_handle<0) { Print("The creation of iVIDyA has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array VIDyA[] with current values of iVIDyA //--- set indexation of array VIDyA[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(VIDyA_handle,0,0,100,true,VIDyA)) return; }
iVolumes
#include <GetIndicatorBuffers.mqh> //---- arrays for indicators double Volumes[]; // array for the indicator iVolumes //---- handles for indicators int Volumes_handle; // handle of the indicator iVolumes //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- creation of the indicator iVolumes Volumes_handle=iVolumes(NULL,0,VOLUME_TICK); //--- report if there was an error in object creation if(Volumes_handle<0) { Print("The creation of iVolumes has failed: Runtime error =",GetLastError()); //--- forced program termination return(-1); } return(0); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- filling an array Volumes[] with current values of iVolumes //--- set indexation of array Volumes[] as timeseries //--- return if there was an error if(!CopyBufferAsSeries(Volumes_handle,0,0,100,true,Volumes)) return; }
Sonuç
- MQL5'teki Uzman Danışmanlarda standart teknik göstergelerin kullanımı önceki sürümde olduğu kadar kolaydır.
- Uzman Danışman’larınızda yalnızca güvenli programlama yöntemlerini kullanın, olası tüm hataları analiz edin ve giderin. Hataların bedeli çok yüksek olabilir, söz konusu sizin mevduatınız!
MetaQuotes Ltd tarafından Rusçadan çevrilmiştir.
Orijinal makale: https://www.mql5.com/ru/articles/31
Ekli dosyalar |
getindicatorbuffers.mqh
(12.5 KB)
Uyarı: Bu materyallerin tüm hakları MetaQuotes Ltd.'a aittir. Bu materyallerin tamamen veya kısmen kopyalanması veya yeniden yazdırılması yasaktır.
Tartışmaya git
MQL5'e Giriş: Basit Uzman Danışman (EA) ve Özel Gösterge nasıl yazılır
MetaTrader 5 İstemci Terminaline dahil edilen MetaQuotes Programlama Dili 5 (MQL5), MQL4'e kıyasla birçok yeni imkana ve daha yüksek performansa sahiptir. Bu makale, bu yeni programlama dili hakkında bilgi edinmenize yardımcı olacaktır. Uzman Danışman ve Özel Göstergenin nasıl yazılacağına dair basit örnekler bu makalede sunulmuştur. Bu örnekleri anlamak için gerekli olan MQL5 dilinin bazı ayrıntılarını da ele alacağız.
MQL5'te Nesne Yaratma ve Yok Etme
İster özel bir nesne, ister dinamik bir dizi veya bir nesne dizisi olsun, her nesne MQL5 programında kendine özgü şekilde oluşturulur ve silinir. Çoğu zaman, bazı nesneler diğer nesnelerin bir parçasıdır ve sonlandırma sırasında nesne silme sırası özellikle önemli hale gelir. Bu makale, nesnelerle çalışma mekanizmalarını kapsayan bazı örnekler sunmaktadır.
Nesne işaretleyicilerini MQL5'te Kullanma
Varsayılan olarak, MQL5'teki tüm nesneler referansla iletilir, ancak nesne işaretçilerini kullanma olasılığı vardır. Ancak, nesne başlatılmamış olabileceğinden, işaretçi denetiminin gerçekleştirilmesi gereklidir. Bu durumda MQL5 programı kritik bir hata ile sonlandırılır ve kaldırılır. Otomatik olarak oluşturulan nesneler böyle bir hataya neden olmaz, dolayısıyla bu anlamda oldukça güvenlidirler. Bu makalede, nesne referansı ile nesne işaretçisi arasındaki farkı anlamaya çalışacağız ve işaretçileri kullanan güvenli kodun nasıl yazılacağını ele alacağız.
Uzman Danışmanlarda Sınırlamalar ve Doğrulamalar
Pazartesi günü bu sembolün alım satımına izin verilir mi? Pozisyon açmak için yeterli para var mı? Zararı Durdur tetiklenirse kayıp ne kadar büyük olur? Bekleyen emirlerin sayısı nasıl sınırlandırılır? Alım satım işlemi mevcut çubukta mı yoksa önceki çubukta mı gerçekleştirildi? Bir alım satım robotu bu tür doğrulamaları gerçekleştiremezse, herhangi bir alım satım stratejisi kaybeden bir stratejiye dönüşebilir. Bu makale, herhangi bir Uzman Danışmanda yararlı olan doğrulama örneklerini gösterir.
Ticaret fırsatlarını kaçırıyorsunuz:
- Ücretsiz ticaret uygulamaları
- İşlem kopyalama için 8.000'den fazla sinyal
- Finansal piyasaları keşfetmek için ekonomik haberler
Kayıt
Giriş yap
Gizlilik ve Veri Koruma Politikasını ve MQL5.com Kullanım Şartlarını kabul edersiniz
Hesabınız yoksa, lütfen kaydolun