MQL5’te Nesne Yönelimli Programlama (Object-Oriented Programming, OOP)

Giriş

Bu makalede, kod yazmayı kolaylaştıran ve DRY (Don’t Repeat Yourself - Kendini Tekrar Etme) kavramının geliştiricilere ve programcılara uygulanmasına olanak tanıyan programlamadaki en önemli konulardan birini paylaşacağız. Ayrıca sayesinde, diğer birçok özelliğin yanı sıra, oluşturulan yazılımın güvenliği de artar. Nesne Yönelimli Programlama (Object-Oriented Programming, OOP) ve bu konsepti MQL5'te (MetaQuotes Language 5) nasıl kullanabileceğimiz ve kodlayabileceğimiz hakkında konuşacağız.

Bu ilginç ve önemli konuyu aşağıdaki bölümlerde ele alacağız:

• OOP nedir?
• MQL5'te OOP
• OOP uygulamaları
• Sonuç

Bu makalenin temel amacı, genel olarak Nesne Yönelimli Programlamanın (OOP) temellerinin ve yazılım oluştururken nasıl kullanılabileceğinin anlaşılmasını sağlamaktır. Daha verimli ve güvenli programlar oluşturmak için bu yaklaşımı MQL5'te nasıl uygulayabileceğimizi öğreneceğiz.

Gerekirse, özellikle C++, Java, Python vb. gibi diğer programlama dillerinde uygulanabilir olduğundan, bu yaklaşım hakkında bilgilendirici kaynaklar bulabilirsiniz. MQL5 dili söz konusu olduğunda, sadece makalenin konusu için değil, MQL5 dilindeki her konu için çok önemli bir kaynak vardır: MQL5 dokümantasyonu. Dokümantasyonda yer alan OOP açıklamalarını inceleyebilirsiniz.

Sorumluluk reddi: Sağlanan tüm bilgiler ‘olduğu gibi’ yalnızca bilgilendirme amaçlıdır, alım-satım tavsiyesi değildir. Bu bilgiler herhangi bir sonucu garanti etmemektedir. Bu materyalleri herhangi bir işlem hesabında kullanırsanız, ortaya çıkabilecek tüm riskler size ait olacaktır.

OOP nedir?

OOP'nin tanımı ile başlayalım. OOP, DRY (Don’t Repeat Yourself - Kendini Tekrar Etme) kavramını uygulayarak iş ve kod tekrarları yapmadan yeniden kullanılabilir yazılımlar oluşturmaya ve geliştirmeye yardımcı olur.

OOP dünyanın doğasına yaklaşmamıza yardımcı olur çünkü nesneler günlük hayatımızda her yerde bizi çevreler. Her bir nesnenin kendi niteliği ve davranışı vardır ve yazılımdaki verilerimizle yapabileceğimiz şey de budur. Nesneler ve sınıflarla ilgileneceğiz, nesne bir sınıfın örneği anlamına gelir ve sınıf da nesne için bir şablondur. Bir sınıf olan şablonun içinde, nesnenin davranışını ayrıntılı olarak tanımlarız.

OOP'nin temel kavramları:

Geliştirmede OOP kullanılırken aşağıdaki ilkeler geçerlidir.

1. Kapsülleme.
2. Soyutlama.
3. Kalıtım.
4. Polimorfizm.

1- Kapsülleme:

Kapsülleme, fonksiyonları ve verileri tek bir sınıfta birleştiren bir yöntemdir. Sınıf içindeki veriler ve fonksiyonlar private (sadece sınıf içinden erişilebilir) veya public (sınıf dışından erişilebilir) olabilir. Kapsülleme, sınıfın uygulanmasının karmaşıklığını gizlemeye yardımcı olur ve geliştiriciye verileri üzerinde tam kontrol sağlayarak tüm bağımlı değerlerin çakışma olmadan takip edilmesine yardımcı olur.

Dolayısıyla kapsülleme, sistemimizin çalışır durumda kalmasını sağlar ve olası birçok hatayı önler, aynı zamanda geliştirici için yüksek düzeyde kontrol sağlar ve tüm yazılım kodunu etkilemeden veya değiştirmeden sınıf verilerini test etmeyi ve işlemeyi kolaylaştırır. Ayrıca hataların giderilmesine yardımcı olur ve kodu basitleştirir.

Aşağıdaki şekil kapsülleme kavramını açıklar:

2- Soyutlama:

Soyutlama, gereksiz ayrıntıları gizleme ve yalnızca gerekli ayrıntıları sunma yöntemidir. Kapsülleme kavramından daha geniştir, ancak aynı hedefe ulaşmaya yardımcı olur: tüm sınıfların uygulanma süreci hakkında tam bilgi sahibi olmadan, yalnızca uygulamanın çalışması için ne yapılması gerektiğini anlayarak verileri korumak ve fonksiyonları uygulamak.

Bu hedefe ulaşmak için iki önemli yöntemi dahil etmemiz gerekir - Arayüz ve Uygulama. Arayüz, sınıfların birbirleriyle etkileşime girmesini sağlayan bir yöntemdir; Uygulama ise kodun tüm ayrıntılarını veya sınıfların mantığını içeren bir yöntemdir. Böylece soyutlama, yazılımın güvenliğini artırmaya yardımcı olur ve ayrıca daha önce oluşturulmuş olanlara dayalı alarak daha fazla yazılım geliştirmemizi sağlayarak kodlama sürecini sıfırdan tekrarlamaktan kaçınmamıza yardımcı olur.

3- Kalıtım:

Adından da anlaşılacağı gibi, kalıtım kavramı eski bir sınıftan yeni bir sınıf türettiğimiz ve yeni sınıfın eskisinin işlevlerini miras aldığı anlamına gelir. Bu durumda, eski sınıf üst sınıf olarak adlandırılırken, türetilen yeni sınıf alt sınıf olarak adlandırılır. Bu kavram, yeniden kullanılabilirliği korurken DRY (kendini tekrar etme) konseptinin uygulanmasına yardımcı olur.

4- Polimorfizm:

Kavramın adını iki parçaya bölersek, (Poly) çok, (Morph) ise biçim anlamına gelir. Yani polimorfizm çok biçimlilik demektir. Bir varlığın birden fazla biçimde davranabilmesidir. Örneğin, farklı şekillerde davranabilen bir toplama metoduna sahip olabiliriz: (a) ve (b) değişkenlerinin toplamını elde edebilen ve ayrıca (a), (b) ve (c) gibi farklı parametreler için toplamı elde edebilen.

Basitçe söylemek gerekirse, polimorfizm bir arayüz ve birçok metot anlamına gelir.

Özetlemek gerekirse, OOP, benzersiz davranışlara ve özelliklere sahip olabilen nesneleri kullanarak yazılım geliştirmeyi organize etmeye odaklanan bir programlama modelidir. Büyük ve karmaşık programlarda, özellikle de sık sık güncelleniyorlarsa faydalı bir modeldir.

OOP’nin özellikleri:

• OOP yaklaşımını uygulayan yazılımlar sınıflar ve fonksiyonlar içerir.
• Kapsülleme ve soyutlama ilkeleri uygulanarak veriler gizlendiği için yüksek güvenlik seviyesi.
• Kod küçük kod bloklarına bölünebildiği için karmaşık projeler üzerinde kolayca çalışılmasına yardımcı olur ve bu da projenin karmaşıklığını azaltabilir.
• Güncelleme ve geliştirme süreçleri daha kolaydır.
• Kalıtım ilkesini uygulayarak kodun yeniden kullanılabilirliği.
• Çakışma olmadan aynı sınıfın birçok örneğini oluşturabilme.

OOP yaklaşımını uygulayabilen birçok programlama dili vardır. En popüler olanları C++, C#, Python, Java, JavaScript, PHP’dir. Bunlara MQL5 de dahildir.

MQL5'te OOP

Bu bölümde, MQL5'teki OOP'ye bakacağız ve nasıl kullanılacağını öğreneceğiz. OOP'nin temelleri olarak bahsettiğimiz gibi, bir nesne için bir plan gibi olması üzere bir sınıf yaratırız. Sınıfın kendisi bir koleksiyondur: değişkenler ve metotlar içerir (metot bir fonksiyonla aynıdır, ancak belirli bir dizi görevi yerine getirmek için sınıfta metot olarak adlandırılır). Burada, sınıf içindeki değişkenlere ve metotlara (veya diğer bir deyişle fonksiyonlara) sınıf üyeleri denildiğini de belirtmekte fayda var. Burada söylememiz gereken şey, OOP konseptinin MQL5'te mevcut olmasının iyi ve takdir edilen bir girişim olduğudur, çünkü kalite ve güvenliğin yanı sıra bahsettiğimiz gibi çok fazla çaba ve işten tasarruf sağlayacaktır.

OOP konseptini MQL5'te uygulamamız gerekiyorsa, aşağıdakileri MQL5'te nasıl kullanabileceğimizi anlamamız gerekir:

• Sınıflar
• Erişim değiştiricileri
• Yapıcılar ve yıkıcılar
• Türetilmiş (alt) sınıflar
• Sanal fonksiyonlar
• Nesneler

Sınıflar:

MQL5'te, bir nesnenin taslağı olacak bir sınıf oluşturmamız gerekiyorsa, bu sınıfı fonksiyonlarda olduğu gibi global kapsamda bildirmemiz gerekir. Bu sınıfı class anahtar kelimesini ve ardından istenen benzersiz tanımlayıcıyı kullanarak oluşturabiliriz, sonrasında iki süslü parantez arasına sınıfın üyeleri olan değişkenlerimizi ve metotlarımızı yerleştiririz, ardından ikinci süslü parantezden sonra sınıf bildirimini sonlandırmak için noktalı virgül koyarız. Bu sınıf bildirimini bir programda veya bir include dosyasında kullanabiliriz.

Aşağıda bu sınıf bildirimine bir örnek verilmiştir:

class Cobject
{
   int var1;       // variable1
   double var2;    // variable1
   void method1(); // Method or function1
};

Örnekten gördüğümüz gibi, sınıfın üç üyesi vardır: iki değişken ve bir metot (veya fonksiyon).

Erişim değiştiricileri:

Bu erişim değiştiricileri sayesinde, sınıf dışında hangi değişkenleri ve fonksiyonları kullanabileceğimizi belirleyebiliriz. public, private ve protected olmak üzere üç erişim anahtar kelimemiz vardır.

• public: sınıf dışında kullanılabilecek üyeleri temsil eder.
• private: sınıf dışında kullanılamayan, ancak sınıf içinde fonksiyonlar tarafından kullanılabilen üyeleri temsil eder. Bu sınıfın alt sınıfı bu private üyeleri kalıtmayacaktır.
• protected: alt sınıflar tarafından kalıtılacak ancak doğası gereği private olan üyeleri temsil eder.

Aşağıda bir örnek verilmiştir:

class Cobject
{
   private:
   int var1;       // variable1
   protected:
   double var2;    // variable1
   public:
   void method1(); // Method or function1
};

Örnekten gördüğümüz üzere, sınıfta biri private, diğeri protected ve üçüncüsü public olmak üzere iki değişkenli üç üyeye sahibiz.

Yapıcılar ve yıkıcılar:

Sınıftaki değişkenleri başlatmamız gerekiyorsa yapıcıyı kullanırız. Bunu yapmadığımız takdirde derleyici tarafından varsayılan olarak oluşturulacaktır ancak bu varsayılan yapıcı görünür olmayacaktır. Ayrıca erişilebilirlik açısından public olmalıdır. Öte yandan, yıkıcı, bir sınıf nesnesi yok edildiğinde otomatik olarak çağrılan bir fonksiyondur. Yıkıcıyı sınıf adıyla aynı olarak yaklaşık işaretiyle (~) çağırabiliriz. Yıkıcı mevcut olsun ya da olmasın, dizge, dinamik dizi ve nesne sonlandırma gerektirdiğinden her halükarda sonlandırılacaktır.

Aşağıda bir yapıcı örneği verilmiştir:

class CPrices
  {
private:
   double               open;         // Open price
   double               high;         // High price
   double               low;          // Low price
   double               close;        // Close price
public:
   //--- Default constructor
                     CPrices(void);
   //--- Parametric constructor
                     CPrices(double o,double h,double l, double c);
  };

Türetilmiş (alt) sınıflar:

Daha önce öğrendiğimiz gibi, kalıtım kavramı OOP'nin en değerli ve kullanışlı özelliklerinden biridir çünkü bir üst sınıftan bir alt sınıf oluşturabiliriz ve bu alt sınıf, private üyeler hariç üst sınıfın tüm üyelerini kalıtır. Daha sonra, bu alt sınıf için yeni değişkenler ve fonksiyonlar ekleyebiliriz.

Bir örnek: fiyatlar için bir üst sınıfımız varsa, aşağıda gösterildiği gibi günlük fiyatlar için bir alt sınıf oluşturabiliriz:

class CDailyPrices : public CPrices
{
public:
   double               open;          // Open price
   double               high;          // High price
   double               low;           // Low price
   double               close;         // Close price
};

Gördüğümüz gibi, üst sınıf adı CPrices'tır ve CDailyPrices alt veya türetilmiş olandır. CPrices'ın tüm public ve protected üyeleri CDailyPrices sınıfının bir parçasıdır ve hala public’tir.

Sanal fonksiyonlar:

Bir metodun (veya fonksiyonun) alt sınıfta çalışma şeklini güncellemek istiyorsak, bunu üst sınıftaki (sanal) fonksiyonu kullanarak yapabiliriz, ardından fonksiyonu alt sınıfta tanımlarız. Örneğin, bir sınıfa dayalı bir fonksiyonun iki farklı versiyonuna sahip olalım. Ana sınıf için, virtual anahtar kelimesini kullanarak fonksiyonu tanımlarız:

class CVar
  {
public:
   virtual 
void varCal();
  };

Daha sonra aynı fonksiyonu alt sınıfta güncelleriz:

class CVar1 : public CVar
{
public:
 int varCal(int x, int y);
}; 

Nesneler:

Nesnelerin benzersiz bir tanımlayıcısı vardır. Tıpkı bir değişken oluşturduğumuzda olduğu gibi, nesne tanımlayıcısından önce tür olarak sınıf adını kullanacağız. Proje için ihtiyaç duyduğumuz kadar sınıflarımıza ait nesne oluşturabiliriz, tek ihtiyacımız olan her biri için benzersiz bir tanımlayıcı kullanmaktır. Nesneyi bildirdikten sonra, nokta (.) kullanarak herhangi bir public üyeye erişebiliriz.

İşlem sayısı (num_trades) tamsayı değişkenine sahip bir sınıfın oluşturulmasını gösteren bir örneğe bakalım:

class CSystrades
{
public:
int num_trades;
};

Daha sonra, bu sınıfa ait system1 adında bir nesne oluşturmamız gerekiyor. Bunu aşağıdaki gibi yaparız:

CSystrades system1;

Devamında bu nesneyi aşağıdaki gibi (3) değeri ile tanımlayabiliriz:

system1.num_trades=3;

Böylece, en önemli noktalardan bazılarını keşfederek OOP'nin MQL5'te nasıl uygulanabileceğine baktık.

OOP uygulamaları

Bu ilginç bölümde, OOP'yi kullanan bazı basit uygulamalar sunacağız.

priceClass uygulaması:

Bu basit uygulamada çeşitli zaman dilimlerindeki fiyatları kontrol etmemiz gerekiyor. Üç zaman dilimi kullanacağız (günlük, haftalık ve aylık). Ayrıca tüm fiyatları (Açılış, Yüksek, Düşük ve Kapanış) tek bir yerde, örneğin Uzman Danışmanlar sekmesinde görmemiz gerekiyor. Devamında daha karmaşık programlar geliştirmeye devam edebiliriz.

Öncelikle aşağıdaki adımları takip ederek sınıfı bildirmemiz gerekiyor:

• class anahtar kelimesini kullanarak, fiyatlar için global kapsamda bir sınıf bildirmemiz ve tüm ortak üyeleri public olarak dahil etmemiz gerekir.
• public anahtar kelimesini kullanacağız.
• Beş değişken oluşturacağız (timeFrame, open, high, low ve close).
• Tüm fiyat verilerini yazdırmak için bir void fonksiyonu oluşturacağız.

class CPrices
  {
public:
   string            timeFrame;
   double            open;
   double            high;
   double            low;
   double            close;
   void              pricesPrint()
     {
      Print(timeFrame," Prices = Open: ",open," - ","High: ",high,"-","Low: ",low,"-","Close: ",close);
     }
  };

Günlük, haftalık ve aylık fiyatlar için sınıftan nesneler oluşturacağız.

CPrices CDailyPrices;
CPrices CWeeklyPrices;
CPrices CMonthlyPrices;

OnInit fonksiyonunun içinde, üç zaman dilimi için aşağıdakileri tanımlayacağız:

• Zaman diliminin adını içeren dizge.
• iOpen fonksiyonunu kullanarak Açılış fiyatı.
• iHigh fonksiyonunu kullanarak Yüksek fiyatı.
• iLow fonksiyonunu kullanarak Düşük fiyatı.
• iClose fonksiyonunu kullanarak Kapanış fiyatı.
• Yazdırma fonksiyonunun (veya metodunun) çağrılması.

int OnInit()
  {
//--- Daily time frame
   CDailyPrices.timeFrame="Daily";
   CDailyPrices.open=(iOpen(Symbol(),PERIOD_D1,1));
   CDailyPrices.high=(iHigh(Symbol(),PERIOD_D1,1));
   CDailyPrices.low=(iLow(Symbol(),PERIOD_D1,1));
   CDailyPrices.close=(iClose(Symbol(),PERIOD_D1,1));
   CDailyPrices.pricesPrint();

//--- Weekly time frame
   CWeeklyPrices.timeFrame="Weekly";
   CWeeklyPrices.open=(iOpen(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.high=(iHigh(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.low=(iLow(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.close=(iClose(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.pricesPrint();

//--- Monthly time frame
   CMonthlyPrices.timeFrame="Monthly";
   CMonthlyPrices.open=(iOpen(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.high=(iHigh(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.low=(iLow(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.close=(iClose(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.pricesPrint();
   return(INIT_SUCCEEDED);
  }

Uzman Danışmanı çalıştırdıktan sonra, Araç Çubuğunun “Uzman Danışmanlar” sekmesinden fiyatları görebiliriz:

Burada üç satıra sahibiz:

• İlk satır günlük Açılış, Yüksek, Düşük ve Kapanış fiyatlarını gösteriyor.
• İkincisi aynı fiyatları gösteriyor ancak haftalık verilere aittir.
• Üçüncü satır da aynı fiyatları gösteriyor ancak aylık verilere aittir.

indicatorClass uygulaması:

OOP yaklaşımını kullanarak dört hareketli ortalama türünün (Simple, Exponential, Smoothed ve Linear Weighted) değerlerini yazdırabilen bir yazılım oluşturmamız gerekiyor. Aşağıda bu tür bir yazılım oluşturmak için basit adımlar açıklanmıştır:

class anahtar kelimesini kullanarak CiMA gösterge sınıfını bildirelim ve bu sınıfın public üyelerini oluşturalım. Bunlar dört ortak değişkendir: MAType - hareketli ortalama türünü tanımlamak için, MAArray - hareketli ortalama dizisini tanımlamak için, MAHandle - her türün tanıtıcısını tanımlamak için ve MAValue - her hareketli ortalamanın değerini tanımlamak için. Ayrıca, her bir hareketli ortalama türünün değerini yazdırmak için valuePrint adında bir void metodu (veya fonksiyonu) ve fonksiyon gövdesi oluşturacağız.

class CiMA
  {
public:
   string            MAType;
   double            MAArray[];
   int               MAHandle;
   double            MAValue;
   void              valuePrint()
     {
      Print(MAType," Current Value: ",MAValue);
     };
  };

Sınıftan her bir hareketli ortalama için aşağıdaki nesneleri oluşturalım:

• Ortalamanın adı
• Ortalamanın tanıtıcısı
• Ortalamanın dizisi

//--- SMA
CiMA CSma;
CiMA CSmaHandle;
CiMA CSmaArray;

//--- EMA
CiMA CEma;
CiMA CEmaHandle;
CiMA CEmaArray;

//--- SMMA
CiMA CSmma;
CiMA CSmmaHandle;
CiMA CSmmaArray;

//--- LWMA
CiMA CLwma;
CiMA CLwmaHandle;
CiMA CLwmaArray;

Her bir hareketli ortalama türü için, OnInit fonksiyonu içinde aşağıdaki adımları gerçekleştirelim:

• Ortalamanın adını tanımlayalım.
• Ortalamanın tanıtıcısını tanımlayalım.
• ArraySetAsSeries fonksiyonunu kullanarak dizi için AS_SERIES bayrağını ayarlayalım.
• CopyBuffer fonksiyonunu kullanarak hareketli ortalama göstergesinin arabellek verilerini alalım.
• Ortalamanın değerini belirleyelim ve NormalizeDouble fonksiyonunu kullanarak normalleştirelim.
• Oluşturduğumuz yazdırma metodunu (veya fonksiyonunu) çağıralım.

int OnInit()
  {
   //--- SMA
   CSma.MAType="Simple MA";
   CSmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_SMA,PRICE_CLOSE);
   ArraySetAsSeries(CSmaArray.MAArray,true);
   CopyBuffer(CSmaHandle.MAHandle,0,0,3,CSmaArray.MAArray);
   CSma.MAValue=NormalizeDouble(CSmaArray.MAArray[1],_Digits);
   CSma.valuePrint();

   //--- EMA
   CEma.MAType="Exponential MA";
   CEmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_EMA,PRICE_CLOSE);
   ArraySetAsSeries(CEmaArray.MAArray,true);
   CopyBuffer(CEmaHandle.MAHandle,0,0,3,CEmaArray.MAArray);
   CEma.MAValue=NormalizeDouble(CEmaArray.MAArray[1],_Digits);
   CEma.valuePrint();

   //--- SMMA
   CSmma.MAType="Smoothed MA";
   CSmmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_SMMA,PRICE_CLOSE);
   ArraySetAsSeries(CSmmaArray.MAArray,true);
   CopyBuffer(CSmmaHandle.MAHandle,0,0,3,CSmmaArray.MAArray);
   CSmma.MAValue=NormalizeDouble(CSmmaArray.MAArray[1],_Digits);
   CSmma.valuePrint();

   //--- LWMA
   CLwma.MAType="Linear-weighted MA";
   CLwmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_LWMA,PRICE_CLOSE);
   ArraySetAsSeries(CLwmaArray.MAArray,true);
   CopyBuffer(CLwmaHandle.MAHandle,0,0,3,CLwmaArray.MAArray);
   CLwma.MAValue=NormalizeDouble(CLwmaArray.MAArray[1],_Digits);
   CLwma.valuePrint();
   return(INIT_SUCCEEDED);
  }

Kodu derleyip çalıştırdıktan sonra, her hareketli ortalama türü için dört satır göreceğiz. Her satır, her bir ortalama türünün değerini gösterir:

Daha önce de söylediğim gibi, bu uygulamalar daha karmaşık görevleri yerine getirecek şekilde geliştirilebilir. Ancak, bu makaledeki görevimiz Nesne Yönelimli Programlamanın (OOP) temellerini ve bu yaklaşımı MQL5'te nasıl uygulayabileceğimizi öğrenmek ve anlamaktır, çünkü bu yararlı yaklaşımı uygularken elde edebileceğimiz birçok beceri vardır.

Sonuç

Bu makalede, genel olarak programlamada çok önemli bir yaklaşımın temellerini öğrendik. Nesne Yönelimli Programlama (OOP), güvenli yazılımlar oluşturmaya yardımcı olur, kodu küçük bloklara bölerek geliştirmeyi basitleştirir, farklı davranışlara sahip olsalar bile herhangi bir çakışma olmadan aynı sınıfın birden fazla örneğini oluşturmaya olanak tanır ve güncelleme yaparken daha fazla esneklik ve güvenlik sağlar.

Ayrıca, tüm bu inanılmaz özellikleri elde etmek için bu önemli yaklaşımın MQL5'te nasıl uygulanacağını öğrendik ve ardından MetaTrader 5'te kullanılmak üzere MQL5'te OOP yaklaşımını uygulayarak oluşturulabilecek bazı basit uygulamaları keşfettik.

Bu makalenin sizin için faydalı olmasını ve MQL5 programlamada çok önemli ve gerekli bir konu olan OOP’yi öğrenmenize yardımcı olmasını umuyorum, çünkü bu OOP yaklaşımını uyguladıktan sonra kodlama yaparken birçok fikrin ne kadar kolay olabileceği konusunda size daha fazla fikir verebilir.

Bu makaleyi beğendiyseniz ve MQL5'te en popüler teknik göstergelere dayalı alım-satım sistemlerinin oluşturulması ve Uzman Danışmanlarda özel teknik göstergelerin geliştirilmesi ve uygulanması hakkında daha fazla bilgi edinmek istiyorsanız, diğer makalelerimi okuyabilirsiniz. Makalelerin tam listesini profilimde bulabilirsiniz.