DocumentazioneSezioni
MQL5 RiferimentoLe basi del linguaggioFunzioniPassaggio di Parametri 

Passaggio di parametri

Ci sono due metodi, con cui il linguaggio macchina può passare argomenti ad un sottoprogramma (funzione). Il primo metodo è quello di inviare un parametro per valore. Questo metodo copia il valore dell' argomento in un parametro di funzione formale. Pertanto, le variazioni di questo parametro all'interno della funzione non hanno alcuna influenza sull'argomento della corrispondente chiamata.

//+--------------------------------------------------------------------------------+
//| Passaggio di parametri per valore                                              |
//+--------------------------------------------------------------------------------+
double FirstMethod(int i,int j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
  }
//+--------------------------------------------------------------------------------+
//| Funzione di avvio del programma Script                                         |
//+--------------------------------------------------------------------------------+
voidOnStart()
  {
//---
   int a=14,b=8;
   Print("a e b prima della chiamata:",a," ",b);
   double d=FirstMethod(a,b);
   Print("a e b dopo la chiamata:",a," ",b);
  }
//--- Risultato dell'esecuzione dello script
// a e b prima della chiamata: 14 8
// a e b dopo la chiamata: 14 8

Il secondo metodo è passare per riferimento. In questo caso, il riferimento ad un parametro (non al suo valore) viene passato ad un parametro di funzione. All'interno della funzione, viene utilizzato per fare riferimento al parametro attuale specificato nella chiamata. Ciò significa che le modifiche dei parametri influenzeranno l'argomento utilizzato per chiamare la funzione.

//+--------------------------------------------------------------------------------+
//| Passaggio di parametri per riferimento                                         |
//+--------------------------------------------------------------------------------+
double SecondMethod(int &i,int &j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
  }
//+--------------------------------------------------------------------------------+
//| Funzione di avvio del programma Script                                         |
//+--------------------------------------------------------------------------------+
voidOnStart()
  {
//---
   int a=14,b=8;
   Print("a e b prima della chiamata:",a," ",b);
   double d=SecondMethod(a,b);
   Print("a e b dopo la chiamata:",a," ",b);
  }
//+--------------------------------------------------------------------------------+
//--- risultato dell'esecuzione dello script
// a e b prima della chiamata: 14 8
// a e b dopo la chiamata: 28 4

MQL5 utilizza entrambi i metodi, con una sola eccezione: gli array, le variabili di tipo struttura e gli oggetti della classe sono sempre passati per riferimento. Al fine di evitare variazioni di parametri attuali (argomenti passati alla chiamata di funzione) utilizziamo lo specificatore di accesso const. Quando si tenta di modificare il contenuto di una variabile dichiarata con l'identificatore const , il compilatore genera un errore.

Nota

Va notato che i parametri vengono passati ad una funzione in ordine inverso, cioè, prima viene calcolato e passato l'ultimo parametro, e poi il penultimo, e così via. L'ultimo parametro calcolato e passato è quello che sta prima dopo la parentesi di apertura.

Esempio:

voidOnStart()
  {
//---
   int a[]={0,1,2};
   int i=0;
 
   func(a[i],a[i++],"First call (i = "+string(i)+")");
   func(a[i++],a[i],"Second call (i = "+string(i)+")");
//Risultato:
// First call (i = 0) : par1 = 1     par2 = 0
// Second call (i = 1) : par1 = 1     par2 = 1
 
  }
//+--------------------------------------------------------------------------------+
//|                                                                                |
//+--------------------------------------------------------------------------------+
void func(int par1,int par2,string comment)
  {
   Print(comment,": par1 = ",par1,"    par2 = ",par2);
  }

Nella prima chiamata (vedi esempio sopra) la variabile i viene prima usata nella concatenazione stringhe:

  "First call (i = "+string(i)+")"

Qui il suo valore non cambia. Poi la variabile i viene utilizzata nel calcolo dell'elemento dell' array a[i++], cioè quando si accede all'elemento dell'array con indice i, la variabile i viene incrementata. E solo dopo ciò, il primo parametro con il valore modificato di i viene calcolato.

Nella seconda chiamata lo stesso valore di i (calcolato sulla prima fase della chiamata di funzione) viene utilizzato per calcolare tutti i tre i parametri. Solo dopo che il primo parametro viene calcolato, la variabile i viene modificata di nuovo.

Vedi anche

Visibilità Ambito e Durata delle Variabili,L'Overload, Funzioni Virtuali, Polimorfismo