Comprendere la Programmazione Orientata agli Oggetti (OOP) in MQL5

Introduzione

In questo articolo condivideremo uno degli argomenti più importanti della programmazione, che ci porterà a codificare in modo semplice e agevole e ci aiuterà ad applicare il concetto di (DRY), che è l’abbreviazione di (Do Not Repeat Yourself) come sviluppatori o programmatori. Oltre ad aumentare la sicurezza di qualsiasi software creato e altre caratteristiche. Parleremo della Programmazione Orientata agli Oggetti (OOP) e di come possiamo utilizzare questo concetto e codificarlo in MQL5 (MetaQuotes Language) comprendendo prima le basi dell'OOP e poi capendo come utilizzarlo in MQL5 vedendo alcune applicazioni.

Pertanto, tratteremo questo interessante e importante argomento attraverso i seguenti tre punti:

• Che cos'è l'OOP
• OOP in MQL5
• Applicazioni OOP
• Conclusioni

L'obiettivo principale di questo articolo è comprendere le basi della programmazione orientata agli oggetti (OOP) in generale e come può essere utile nella creazione di software. Da lì, impareremo come applicare questo approccio in MQL5 per utilizzare ciò che può aiutarci a creare un software più efficace e sicuro applicando questo incredibile approccio.

Sarà molto utile per chiunque saperne di più su questo approccio OOP. Ci sono risorse molto importanti e informative su questo metodo in generale, soprattutto perché è applicabile ad altri linguaggi di programmazione come C++, Java, Python e altri. Nel linguaggio MQL5, c'è una risorsa molto importante non solo per l'argomento dell'articolo, ma per ogni singolo argomento del linguaggio MQL5 ovvero la documentazione MQL5, che può essere consultata attraverso il link Documentazione MQL5 OOP.

Avvertenza: Tutte le informazioni sono fornite "così come sono" solo a scopo didattico e non sono preparate per scopi commerciali o di consulenza. Le informazioni non garantiscono alcun tipo di risultato. Se scegliete di utilizzare questi materiali su uno qualsiasi dei vostri conti di trading, lo farete a vostro rischio e pericolo e sarete gli unici responsabili.

Che cos'è l'OOP

In questo argomento impareremo le basi dell'OOP in generale, quindi iniziamo questo interessante tema definendo l'OOP. OOP è l'abbreviazione di Object-Oriented Programming (programmazione orientata agli oggetti) ed è un paradigma della programmazione informatica, aiuta a creare e sviluppare software riutilizzabile senza duplicare il lavoro e il codice e questo ci aiuta ad applicare il concetto di DRY (Do not Repeat Yourself).

Come vedremo, l'OOP ci aiuta ad avvicinarci alla natura del mondo, perché tutto ciò che ci circonda è creato da oggetti e ognuno di essi ha la sua natura e il suo comportamento e questo è ciò che possiamo fare con i nostri dati nel software. Se vogliamo approfondire l'OOP, dobbiamo sapere che avremo a che fare con oggetti e classi; per oggetto si intende un'istanza di una classe e la classe è un modello per l'oggetto. All'interno del modello, che è la classe, si definisce il comportamento di questo oggetto in modo dettagliato.

Concetti di base dell'OOP:

Quando si applica l'OOP al software, si applicano i seguenti principi.

1. Incapsulamento.
2. Astrazione.
3. Eredità.
4. Polimorfismo.

1- Incapsulamento:

L'incapsulamento è il metodo che consente di collegare funzioni e dati in una classe; i dati e le funzioni della classe possono essere privati, cioè accessibili solo all'interno della classe, oppure pubblici, cioè accessibili all'esterno della classe. Il concetto di Incapsulamento aiuta a nascondere la complessità dell'implementazione della classe e dà allo sviluppatore il pieno controllo dei suoi dati, aiutandolo a tenere traccia di tutti i valori che dipendono da altri senza conflitti.

Quindi, possiamo dire che l'incapsulamento aiuta a mantenere il nostro sistema attivo e funzionante e a evitare molti possibili errori, oltre a fornire un elevato livello di controllo per lo sviluppatore e ad aiutare a testare ed elaborare i dati delle classi in modo più agevole e semplice senza influenzare o modificare l'intero codice del software. Secondo quanto detto, aiuta anche a risolvere gli errori e a evitare che la codifica sia complicata.

L'immagine seguente rappresenta il concetto di Incapsulamento:

2- Astrazione:

L'astrazione è il metodo per nascondere i dettagli non necessari e presentare solo quelli essenziali. È più ampia del concetto di Incapsulamento, ma aiuta a raggiungere lo stesso obiettivo: proteggere i dati e implementare le funzioni senza sapere tutto sul processo di implementazione di tutte le classi, ma conoscendo solo ciò che è necessario fare per consentire l'implementazione.

Per farlo, dobbiamo includere due metodi importanti: l'Interfaccia e l'Implementazione. L'interfaccia è il metodo che permette alle classi di interagire e di operare tra loro, mentre l'implementazione è il metodo che contiene tutti i dettagli del codice o la logica dei dettagli delle classi. Quindi, l'Astrazione aiuta ad aumentare la sicurezza del software e aiuta anche a non ripetere il nostro processo di codifica o a ricodificare da zero, ma solo a sviluppare e codificare altre applicazioni basate su quella ben creata.

3- Ereditarietà:

Dal suo nome, il concetto di Ereditarietà significa che abbiamo derivato una nuova classe da una vecchia e che la nuova eredita le caratteristiche della vecchia, in questo caso la vecchia classe è chiamata genitore o superclasse e la nuova classe derivata è chiamata classe figlia. Questo concetto aiuta ad applicare il concetto di DRY (Do not Repeat Yourself), ma fornisce l'idea principale di riusabilità.

4- Polimorfismo:

Dal nome di questo concetto, se dividiamo la parola in due segmenti, troveremo (Poli) che significa molti o multipli e (Morfismo) che significa forma, il che vuol dire che il concetto di polimorfismo aiuta un'entità ad essere in grado di comportarsi in molte o più forme, ad esempio se abbiamo un metodo Sum che può comportarsi in modo diverso, come uno che può ottenere la somma delle variabili (a) e (b) e un altro che può ottenere la somma ma per parametri diversi come (a), (b) e (c).

Semplicemente, polimorfismo significa un'interfaccia e molti o molteplici metodi.

Possiamo riassumere quanto detto dicendo che l'OOP è un modello di programmazione informatica che si concentra sull'organizzazione della progettazione del software attraverso oggetti che possono avere comportamenti e caratteristiche uniche e questo è un metodo utile in software grandi e complessi, soprattutto se questo software viene aggiornato e manipolato molto.

Attributi e caratteristiche dell'OOP:

• Il software che applica l'approccio OOP comprende classi e funzioni.
• Elevato livello di sicurezza, in quanto i dati vengono nascosti applicando i principi di incapsulamento e astrazione.
• Aiuta a lavorare facilmente su progetti complessi, poiché il codice può essere suddiviso in piccoli blocchi di codice e questo può diminuire la complessità del progetto.
• I processi di aggiornamento e sviluppo sono più semplici.
• Riusabilità del codice applicando il principio di ereditarietà.
• Possibilità di creare molte istanze della stessa classe senza conflitti.

Ci sono molti linguaggi di programmazione che hanno la capacità di applicare l'approccio OOP e i più popolari sono ad esempio C++, C#, Python, Java, JavaScript, PHP e altri. Tra questi linguaggi a cui possiamo applicare l'approccio OOP c'è il linguaggio MQL5, e questo e ciò che impareremo nell'argomento seguente.

OOP in MQL5

In questo argomento, impareremo a conoscere l'OOP in MQL5 e come utilizzarlo. Come abbiamo detto nelle basi dell'OOP, creiamo una classe per essere come un progetto per un oggetto e la classe stessa è una collezione o contiene variabili e metodi che sono gli stessi di una funzione, ma nella classe sono chiamati metodi per eseguire una serie specifica di compiti. È bene ricordare che le variabili e i metodi o le funzioni all'interno della classe sono chiamati membri della classe. Quello che dobbiamo dire qui è che si tratta di uno sforzo valido e apprezzato che l'applicazione del concetto di OOP sia disponibile in MQL5, poiché risparmierà molti sforzi e lavori, come abbiamo detto, oltre alla qualità e alla sicurezza.

Se vogliamo applicare il concetto di OOP in MQL5, dobbiamo comprendere come utilizzare quanto segue in MQL5:

• Classi
• Modificatore di Accesso
• Costruttori e Distruttori
• Classi Derivate (figlie)
• Funzioni Virtuali
• Oggetti

Classi:

In MQL5, se abbiamo bisogno di creare una classe che sia un modello di un oggetto, dobbiamo dichiarare questa classe a livello globale, come le funzioni. Possiamo creare questa classe usando la parola chiave class seguita dal nome univoco desiderato, poi tra o all'interno delle due parentesi graffe possiamo inserire le nostre variabili e i metodi che sono membri della classe, quindi dopo la seconda parentesi graffa inseriamo un punto e virgola per terminare la dichiarazione della classe. A proposito, possiamo usare questa dichiarazione di classe nel programma o nel file include.

Di seguito è riportato un esempio di dichiarazione di classe:

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

Come si può vedere nell'esempio precedente, abbiamo tre membri della classe, due variabili e un metodo o funzione.

Modificatori di Accesso:

Tramite questi Modificatori di Accesso, possiamo determinare quali variabili e funzioni possiamo utilizzare al di fuori della classe. Abbiamo tre parole chiave di accesso, che sono: public, private e protected.

• Public: rappresenta i membri che possono essere utilizzati al di fuori della classe.
• Private: rappresenta i membri che non possono essere utilizzati al di fuori della classe, ma sono utilizzabili solo all'interno della classe dalle funzioni. La classe figlia di questa classe non erediterà questi membri privati.
• Protected: rappresenta i membri che saranno ereditati dalle classi figlie, ma sono privati per natura.

Se vogliamo vedere un esempio, possiamo vedere il seguente:

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

Come si può vedere nell'esempio precedente, abbiamo tre membri della classe con due variabili, una private e l'altra protected, mentre il terzo membro è public.

Costruttori e Distruttori:

Se dobbiamo inizializzare le variabili della classe, usiamo il costruttore. Sarà creato di default daI compilatore, se non lo abbiamo fatto, ma il costruttore di default non sarà visibile. Inoltre, deve essere public per l'accessibilità. Dall’altro lato, il distruttore è una funzione chiamata automaticamente quando un oggetto di classe viene distrutto. Possiamo chiamare il distruttore come il nome della classe con una tilde (~). Indipendentemente dal fatto che il distruttore esista o meno, la stringa, l'array dinamico e l'oggetto richiedono la deinizializzazione, quindi saranno comunque deinizializzati.

Di seguito è riportato un esempio di Costruttore:

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);
  };

Classi Derivate (figlie):

Come abbiamo imparato in precedenza, il concetto di ereditarietà è una delle caratteristiche più preziose e utili dell'OOP, perché possiamo creare una classe figlia da una classe super o genitore e questa classe figlia eredita tutti i membri della classe genitore, tranne quelli privati. Dopodiché, possiamo aggiungere nuove variabili e funzioni per quella classe figlia.

Se abbiamo bisogno di un esempio, possiamo vederlo attraverso il seguente: se abbiamo una classe genitore per i prezzi, possiamo creare una classe figlia per i prezzi giornalieri, come quella che segue:

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

Come possiamo vedere, il nome della classe genitore è CPrices e CDailyPrices è la classe figlia o derivata. Ora, tutti i membri public e protected di CPrices fanno parte della classe CDailyPrices e sono ancora pubblici.

Funzioni Virtuali:

Se vogliamo aggiornare il modo in cui un metodo o una funzione opera in una classe figlia, possiamo farlo utilizzando la funzione (virtual) nella classe genitore e definendo la funzione nella classe figlia. Ad esempio, se abbiamo due versioni diverse di una funzione basata sulla classe. Per la classe genitore, definiamo la funzione utilizzando la parola chiave virtual

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

Poi si aggiornerà la stessa funzione nella classe figlia

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

Oggetti:

Gli oggetti sono l'identificatore univoco, come quando si crea una variabile, ma useremo il nome della classe come tipo prima dell'identificatore dell'oggetto. Possiamo creare molti oggetti appartenenti alle nostre classi, se ne abbiamo bisogno per il progetto, basta usare un identificatore unico per tutti. Dopo aver dichiarato l'oggetto, possiamo accedere a qualsiasi membro pubblico utilizzando il simbolo (.), che è il punto.

Vediamo un esempio per comprendere chiaramente che se creiamo una classe che ha una variabile intera del numero di trade (num_trades)

class CSystrades
{
public:
int num_trades;
};

Occorre poi creare un oggetto appartenente a questa classe, chiamato system1; per farlo, si procederà come segue

CSystrades system1;

Allora possiamo definire questo oggetto con il valore (3) come il seguente

system1.num_trades=3;

Ora abbiamo capito come applicare l'approccio OOP in MQL5, imparando alcune delle idee più importanti in questo argomento.

Applicazioni OOP

In questa interessante parte presenteremo alcune semplici applicazioni dell'approccio OOP nel nostro software per capire bene come possiamo usarlo e quanto può essere utile.

Applicazione della classe del prezzo:

In questa semplice applicazione, dobbiamo controllare i prezzi di più time frame e in questo esempio, presenteremo tre time frame (giornaliero, settimanale e mensile); in questo caso dobbiamo vedere anche tutti i prezzi (apertura, massimo, minimo, chiusura) e dobbiamo vederli in un unico posto, diciamo nella scheda Esperti. In seguito, possiamo sviluppare ulteriormente questo semplice esempio per implementare un software più avanzato.

Per prima cosa, dobbiamo dichiarare la classe attraverso il seguente passaggio:

• Dobbiamo dichiarare una classe per i prezzi a livello globale e includere tutti i membri comuni come pubblici, utilizzando la parola chiave class.
• Utilizzare la parola chiave public.
• Creare cinque variabili (timeframe, open, high, low e close).
• Creare una funzione void per stampare tutti i dati relativi ai prezzi.

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);
     }
  };

Creare oggetti della classe per i prezzi giornalieri, settimanali e mensili.

CPrices CDailyPrices;
CPrices CWeeklyPrices;
CPrices CMonthlyPrices;

All'interno della funzione OnInit, definiremo quanto segue per i tre time frame:

• Definizione della stringa time frame.
• Definizione del prezzo di apertura tramite la funzione iOpen.
• Definizione del prezzo massimo con la funzione iHigh.
• Definizione del prezzo minimo con la funzione iLow.
• Definizione del prezzo di chiusura mediante la funzione iClose.
• Chiamata della funzione o del metodo di stampa.

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);
  }

Successivamente, i prezzi stampati dopo l'esecuzione di questo expert si trovano nella scheda Esperti della casella degli strumenti, come di seguito indicato:

Come si può vedere nell'immagine precedente, abbiamo tre righe stampate:

• La prima riga stampa i prezzi giornalieri di apertura, massimo, minimo e chiusura.
• La seconda stampa gli stessi prezzi, ma con dati settimanali.
• Anche la terza riga stampa la stessa cosa, ma con i dati mensili.

Applicazione della classe indicatore:

Dobbiamo creare un software che sia in grado di stampare i valori di quattro tipi di media mobile (media Semplice, Esponenziale, Attenuata e Ponderata-Lineare) utilizzando l'approccio OOP. I seguenti sono i semplici passaggi per creare questo tipo di software:

Dichiariamo la classe CiMA dell'indicatore utilizzando la parola chiave class e creiamo i membri pubblici di questa classe, che sono quattro variabili comuni: MAType per definire il tipo di media mobile, MAArray per definire l'array della media mobile, MAHandle per definire l'handle di ogni tipo, MAValue per definire il valore di ogni media mobile. Creare un metodo o una funzione void valuePrint e il corpo della funzione per stampare il valore di ogni tipo di media mobile.

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

Creare i seguenti oggetti per ogni media mobile della classe:

• Il nome della media
• L’handle (gestore) della media
• L'array della media

//--- 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;

All'interno della funzione OnInit verranno eseguite le seguenti operazioni per ogni tipo di media mobile:

• Definire il nome della media.
• Definire l’handle della media.
• Impostazione del flag AS_SERIES all’array utilizzando ArraySetAsSeries.
• Ottenere i dati del buffer dell'indicatore di media utilizzando la funzione CopyBuffer.
• Definire il valore della media e normalizzarlo utilizzando la funzione NormalizeDouble.
• Chiamare il metodo o la funzione creata Print

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);
  }

Dopo la compilazione e l'esecuzione di questo codice si trovano quattro righe per ogni tipo di media mobile, ciascuna delle quali stampa il valore della media come di seguito indicato:

Come ho detto prima, possiamo sviluppare queste applicazioni per implementare compiti più complicati e avanzati, ma qui l'obiettivo è imparare e comprendere le basi della Programmazione Orientata agli Oggetti (OOP) e come possiamo applicare questo approccio in MQL5, perché ci sono molte caratteristiche che possiamo ottenere applicando questo utile metodo.

Conclusioni

In questo articolo abbiamo appreso le basi di un argomento e di un approccio molto importante nella programmazione in generale. Abbiamo imparato quanto questo approccio è molto utile nella progettazione del nostro software, perché ci aiuta a creare un software sicuro e altamente protetto, ci aiuta a diminuire la complessità della creazione del software dividendo il codice in piccoli blocchi che rendono il processo di codifica più semplice, ci aiuta anche a creare molte istanze della stessa classe senza alcun conflitto, anche se ha un comportamento diverso, e tutto questo ci dà maggiore flessibilità e sicurezza nell'aggiornamento del nostro software.

Abbiamo imparato anche come applicare questo importante metodo in MQL5 per ottenere tutte queste incredibili caratteristiche e poi abbiamo imparato alcune semplici applicazioni che possono essere create applicando l'approccio OOP in MQL5 per utilizzarle in MetaTrader 5.

Spero che questo articolo vi sia stato utile e che vi abbia aiutato a imparare un argomento molto importante e cruciale nella programmazione MQL5, in quanto potrebbe darvi maggiori informazioni su quante idee possono essere facili da codificare dopo aver applicato questo approccio OOP.

Se vi è piaciuto questo articolo e volete saperne di più su come creare sistemi di trading in MQL5 da utilizzare nella MetaTrader 5 basati sugli indicatori tecnici più popolari e su come creare un indicatore tecnico personalizzato e utilizzarlo nel vostro Expert Advisor, potete leggere gli altri miei articoli su questi argomenti attraverso la pubblicazione sul mio profilo e spero che anche voi li troviate utili.