Descargar MetaTrader 5

Traspaso de parámetros

Existen dos métodos mediante los cuales el lenguaje de programación puede pasar el argumento al subprograma (función). El primer modo consiste en traspasar los parámetros por valor. Este método copia el valor del argumento en el parámetro formal de la función. Por tanto, cualquieras que sean las modificaciones de este parámetro dentro de la función, no tendrán ninguna influencia sobre el correspondiente argumento de llamada.

//+------------------------------------------------------------------+
//| traspaso de parámetros por valor                                  |
//+------------------------------------------------------------------+
double FirstMethod(int i,int j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int a=14,b=8;
   Print("a y b antes de la llamada:",a," ",b);
   double d=FirstMethod(a,b);
   Print("a y b después de la llamada:",a," ",b);
  }
//--- resultado de ejecución del script
//  a y b antes de la llamada: 14 8
//  a y b después de la llamada: 14 8

El segundo modo es el traspaso de parámetros por referencia. En este caso la referencia al parámetro (y no su valor) se pasa al parámetro de la función. Se usa dentro de la función para dirigirse al parámetro actual indicado en la llamada. Esto significa que las modificaciones del parámetro van a influir sobre el argumento utilizado para invocar la función.

//+------------------------------------------------------------------+
//| traspaso de parámetros por referencia                                    |
//+------------------------------------------------------------------+
double SecondMethod(int &i,int &j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int a=14,b=8;
   Print("a y b antes de la llamada:",a," ",b);
   double d=SecondMethod(a,b);
   Print("a y b después de la llamada:",a," ",b);
  }
//+------------------------------------------------------------------+
//--- resultado de ejecución del script
//  a y b antes de la llamada: 14 8
//  a y b después de la llamada: 28 4

MQL5 utiliza los dos métodos, salvo una excepción: los arrays, variables del tipo de estructuras y objetos de clases siempre se traspasan por referencia. Para excluir los cambios de los parámetros actuales (argumentos pasados al invocar una función) es necesario usar el especificador de acceso const. Cuando se intenta cambiar el contenido de la variable que ha sido declarada con el especificador const, el compilador mostrará un error.

Nota

Hay que recordar que los parámetros se traspasan a una función del revés, es decir, al principio se calcula y se pasa el último parámetro, luego el penúltimo, etc. En último lugar se calcula y se pasa el parámetro que está primero después de las llaves.

Ejemplo:

void OnStart()
  {
//---
   int a[]={0,1,2};
   int i=0;
 
   func(a[i],a[i++],"La primera llamada(i = "+string(i)+")");
   func(a[i++],a[i],"La segunda llamada(i = "+string(i)+")");
// Resultado:
// Primera llamada(i=0) : par1 = 1     par2 = 0
// Segunda llamada(i=1) : par1 = 1     par2 = 1
 
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void func(int par1,int par2,string comment)
  {
   Print(comment,": par1 = ",par1,"    par2 = ",par2);
  }

 

Durante la primera llamada en el ejemplo mencionado, al principio la variable i toma parte en la concatenación de cadenas de caracteres

  "La primera llamada(i = "+string(i)+")"

además allí su valor no se cambia. Luego la variable i toma parte en el calculo del elemento del array a[i++], es decir, después de tomar el elemento i del array, la variable i se incrementa. Y sólo después de eso se calcula el primer parámetro con el valor cambiado de la variable i.

En la segunda llamada durante el cálculo de todos los tres parámetros, se usa el mismo valor de i que ha sido cambiado durante la primera invocación de la función, y sólo una vez calculado el primer parámetro, la variable i vuelve a cambiarse.

Véase también

Visibilidad y tiempo de vida de variables, Sobrecarga, Funciones virtuales, Polimorfismo

 


Actualizado: 2015.12.03