Programación en MQL5 para tradersProgramación orientada a objetosClases e interfacesSobrecarga de operadores

Download in one file:

Sobrecarga de operadores

En el capítulo Expresiones descubrimos varias operaciones definidas para tipos integrados. Por ejemplo, para variables del tipo double, podríamos evaluar la siguiente expresión:

double a = 2.0, b = 3.0, c = 5.0;
double d = a * b + c;

Sería conveniente utilizar una sintaxis similar cuando se trabaja con tipos definidos por el usuario, como las matrices:

Matrix a(3, 3), b(3, 3), c(3, 3); // creating 3x3 matrices
// ... somehow fill in a, b, c
Matrix d = a * b + c;

MQL5 ofrece esta oportunidad gracias a la sobrecarga de operadores.

Esta técnica se organiza describiendo los métodos con un nombre que comienza por la palabra clave operator e incluyendo a continuación un símbolo (o secuencia de símbolos) de una de las operaciones admitidas. De forma generalizada, esto puede representarse de la siguiente manera:

result_type operator@ ( [type parameter_name] );

Aquí @, símbolo(s) de la operación.

La lista completa de operaciones en MQL5 se ha proporcionado en la sección Prioridades de las operaciones; no obstante, no todas ellas pueden sobrecargarse.

Prohibidas para sobrecarga:

dos puntos '::', resolución de contexto;
paréntesis '()', «llamada a función» o «agrupación»;
punto '.', «desreferenciación»;
ampersand '&', «dirección», operador unario (no obstante, el ampersand está disponible como operador binario «a nivel de bits AND»);
ternario condicional '?:';
coma ','.

Todos los demás operadores están disponibles para sobrecarga. Las prioridades de los operadores de sobrecarga no pueden cambiarse, siguen siendo iguales a la precedencia estándar, por lo que debe utilizarse la agrupación con paréntesis si es necesario.

No se puede crear una sobrecarga para un carácter nuevo que no esté incluido en la lista estándar.

Todos los operadores se sobrecargan teniendo en cuenta su condición de unarios o binarios, es decir, se preserva el número de operandos requeridos. Como cualquier método de clase, la sobrecarga de operadores puede devolver un valor de algún tipo. En este caso, el tipo mismo debe elegirse en función de la lógica prevista de utilización del resultado de la función en las expresiones (véase más adelante).

Los métodos de sobrecarga de operadores tienen la siguiente forma (en lugar del símbolo '@', se sustituye el símbolo o símbolos del operador requerido):

Nombre	Cabecera del método	Uso en una expresión	Función es equivalente a
prefijo unario	tipo operator@()	@object	object.operator@()
postfijo unario	tipo operator@(int)	object@	object.operator@(0)
binario	tipo operator@(tipo parameter_name)	object@argument	object.operator@(argument)
índice	tipo operator[](tipo index_name)	object[argument]	object.operator[](argument)

Los operadores unarios no admiten parámetros. De los operadores unarios, sólo los operadores de incremento '++' y decremento '--' admiten la forma postfija además de la forma prefija; todos los demás operadores unarios sólo admiten la forma prefija. Especificar un parámetro anónimo de tipo int se utiliza para denotar la forma postfija (para distinguirla de la forma prefija), pero el parámetro en sí se ignora.

Los operadores binarios deben tomar un parámetro. Para el mismo operador son posibles varias variantes sobrecargadas con un parámetro de tipo diferente, incluido el mismo tipo que la clase del objeto actual. En este caso, objetos como los parámetros sólo pueden pasarse por referencia o por puntero (esto último es sólo para objetos de clase, pero no para estructuras).

Los operadores sobrecargados pueden utilizarse tanto a través de la sintaxis de las operaciones como parte de las expresiones (que es la razón principal de la sobrecarga) como de la sintaxis de las llamadas a métodos; ambas opciones se muestran en la tabla anterior. El equivalente funcional hace más evidente que, técnicamente hablando, un operador no es más que una llamada a un método sobre un objeto, con el objeto a la derecha del operador prefijo y a la izquierda del símbolo para todos los demás. Al método del operador binario se le pasará como argumento el valor o expresión que esté a la derecha del operador (puede ser, en particular, otro objeto o variable de un tipo integrado).

De ello se deduce que los operadores sobrecargados no tienen la propiedad conmutativa: a@b no es generalmente igual a b@a, porque para a, el operador @ puede estar sobrecargado, pero b no lo está. Además, si b es una variable o un valor de tipo integrado, entonces, en principio, no se puede sobrecargar el comportamiento estándar para ella.

Como primer ejemplo, consideremos la clase Fibo para generar números a partir de la serie de Fibonacci (ya hemos realizado una implementación de esta tarea utilizando funciones, véase Definición de funciones). En la clase proporcionaremos 2 campos para almacenar el número actual y anterior de la fila: current y previous, respectivamente. El constructor por defecto los inicializará con los valores 1 y 0. También proporcionaremos un constructor de copia (FiboMonad.mq5).

class Fibo
{
   int previous;
   int current;
public:
   Fibo() : current(1), previous(0) { }
   Fibo(const Fibo &other) : current(other.current), previous(other.previous) { }
   ...
};

El estado inicial del objeto: el número actual es 1, y el anterior es 0. Para encontrar el siguiente número de la serie, sobrecargamos los operadores de incremento prefijo y postfijo.

   Fibo *operator++() // prefix
   {
      int temp = current;
      current = current + previous;
      previous = temp;
      return &this;
   }

   Fibo operator++(int) // postfix
   {
      Fibo temp = this;
      ++this;
      return temp;
   }

Tenga en cuenta que el método prefijo no devuelve un puntero al objeto actual Fibo una vez modificado el número, sino que el método postfijo vuelve a un nuevo objeto con el contador anterior guardado, lo que corresponde a los principios del incremento postfijo.

Si es necesario, el programador, por supuesto, puede sobrecargar cualquier operación de forma arbitraria. Por ejemplo, es posible calcular el producto, enviar el número al registro o hacer algo más en la implementación del incremento. No obstante, se recomienda ceñirse al enfoque en el que la sobrecarga de operadores realiza acciones intuitivas.

Implementamos las operaciones de decremento de forma similar: devolverán el número anterior de la serie.

   Fibo *operator--() // prefix
   {
      int diff = current - previous;
      current = previous;
      previous = diff;
      return &this;
   }

   Fibo operator--(int) // postfix
   {
      Fibo temp = this;
      --this;
      return temp;
   }

Para obtener un número de una serie por un número dado, sobrecargaremos la operación de acceso al índice.

   Fibo *operator[](int index)
   {
      current = 1;
      previous = 0;
      for(int i = 0; i < index; ++i)
      {
         ++this;
      }
      return &this;
   }

Para obtener el número actual contenido en la variable actual, vamos a sobrecargar el operador '~' (ya que rara vez se utiliza).

   int operator~() const
   {
      return current;
   }

Sin esta sobrecarga, seguiría siendo necesario implementar algún método público para leer el campo privado current. Utilizaremos este operador para obtener números con Print.

También debe sobrecargar la asignación para mayor comodidad.

   Fibo *operator=(const Fibo &other)
   {
      current = other.current;
      previous = other.previous;
      return &this;
   }

   Fibo *operator=(const Fibo *other)
   {
      current = other.current;
      previous = other.previous;
      return &this;
   }

Veamos cómo funciona todo.

void OnStart()
{
   Fibo f1, f2, f3, f4;
   for(int i = 0; i < 10; ++i, ++f1) // prefix increment
   {
      f4 = f3++; // postfix increment and assignment overloading
   }

   // compare all values obtained by increments and by index [10]
   Print(~f1, " ", ~f2[10], " ", ~f3, " ", ~f4); // 89 89 89 55

   // counting in opposite direction, down to 0
   Fibo f0;
   Fibo f = f0[10]; // copy constructor (due to initialization)
   for(int i = 0; i < 10; ++i)
   {
      // prefix decrement
      Print(~--f); // 55, 34, 21, 13, 8, 5, 3, 2, 1, 1
   }
}

Los resultados son los esperados. Aun así, hay que tener en cuenta un detalle:

   Fibo f5;
   Fibo *pf5 = &f5;

   f5 = f4;   // call Fibo *operator=(const Fibo &other)
   f5 = &f4;  // call Fibo *operator=(const Fibo *other)
   pf5 = &f4; // calls nothing, assigns &f4 to pf5!

La sobrecarga del operador de asignación para un puntero sólo funciona cuando se accede a través de un objeto. Si el acceso se realiza a través de un puntero, se produce una asignación estándar de un puntero a otro.

El tipo de devolución de un operador sobrecargado puede ser uno de los tipos integrados, un tipo de objeto (de una clase o estructura) o un puntero (sólo para objetos de clase).

Para devolver un objeto (una instancia, no una referencia), la clase debe implementar un constructor de copia. De esta forma se producirá una duplicación de instancias, lo que puede afectar a la eficiencia del código. Si es posible, debe devolver un puntero.

Sin embargo, cuando se devuelve un puntero, hay que asegurarse de que no se está devolviendo un objeto local automático (que se borrará cuando salga la función, y el puntero dejará de ser válido), sino alguno ya existente; por regla general, se devuelve &this.

Devolver un objeto o un puntero a un objeto permite «enviar» el resultado de un operador sobrecargado a otro, y construir así expresiones complejas del mismo modo que estamos acostumbrados a hacerlo con los tipos integrados. Si devuelve void será imposible utilizar el operador en expresiones. Por ejemplo, si el operador '=' se define con el tipo void, la asignación múltiple dejará de funcionar:

Type x, y, z = 1; // constructors and initialization of variables of a certain class
x = y = z; // assignments, compilation error

La cadena de asignación va de derecha a izquierda, y y = z devolverá vacío.

Si los objetos sólo contienen campos de tipos integrados (incluidos los arrays), entonces no es necesario redefinir el operador de asignación o copia '=' de objetos de la misma clase: MQL5 proporciona copia «uno a uno» de todos los campos por defecto. El operador de asignación o copia no debe confundirse con el constructor de copia y la inicialización.

Pasemos ahora al segundo ejemplo: trabajar con matrices (Matrix.mq5).

Tenga en cuenta, por cierto, que los tipos de objeto integrados matrices y vectores han aparecido recientemente en MQL5. Utilizar los tipos integrados o los suyos propios (o tal vez combinarlos) es decisión de cada desarrollador. La implementación rápida y lista para usar de muchos métodos populares en tipos integrados resulta cómoda y elimina la codificación rutinaria. Por otro lado, las clases personalizadas le permiten adaptar los algoritmos a sus tareas. Aquí proporcionamos la clase Matrix a modo de tutorial.

En la clase matriz, almacenaremos sus elementos en un array dinámico unidimensional m. En los tamaños, seleccione las variables rows y columns.

class Matrix
{
protected:
   double m[];
   int rows;
   int columns;
   void assign(const int r, const int c, const double v)
   {
      m[r * columns + c] = v;
   }

public:
   Matrix(const Matrix &other) : rows(other.rows), columns(other.columns)
   {
      ArrayCopy(m, other.m);
   }

   Matrix(const int r, const int c) : rows(r), columns(c)
   {
      ArrayResize(m, rows * columns);
      ArrayInitialize(m, 0);
   }

El constructor principal toma dos parámetros (dimensiones de la matriz) y asigna memoria para el array. También hay un constructor de copia de la otra matriz other. Aquí y más adelante, las funciones integradas para trabajar con arrays se utilizan de forma masiva (en particular, ArrayCopy, ArrayResize, ArrayInitialize); se abordarán en otro capítulo.

Organizamos el llenado de elementos desde un array externo sobrecargando el operador de asignación:

   Matrix *operator=(const double &a[])
   {
      if(ArraySize(a) == ArraySize(m))
      {
         ArrayCopy(m, a);
      }
      return &this;
   }

Para implementar la suma de dos matrices, sobrecargamos las operaciones '+=' y '+':

   Matrix *operator+=(const Matrix &other)
   {
      for(int i = 0; i < rows * columns; ++i)
      {
         m[i] += other.m[i];
      }
      return &this;
   }

   Matrix operator+(const Matrix &other) const
   {
      Matrix temp(this);
      return temp += other;
   }

Tenga en cuenta que el operador '+=' devuelve un puntero al objeto actual después de que este haya sido modificado, mientras que el operador '+' devuelve una nueva instancia por valor (se utilizará el constructor de copia), y el propio operador tiene el modificador const, por lo que el cómo no cambia el objeto actual.

El operador '+' es esencialmente un envoltorio que delega todo el trabajo al operador '+=', habiendo creado previamente una copia temporal de la matriz actual bajo el nombre temp para llamarla. Así, temp se añade a other mediante una llamada interna al operador '+=' (modificándose temp) y luego se devuelve como resultado del ' +'.

La multiplicación de matrices se sobrecarga de forma similar, con dos operadores '*=' y '*'.

   Matrix *operator*=(const Matrix &other)
   {
      // multiplication condition: this.columns == other.rows
     // the result will be a matrix of size this.rows by other.columns
      Matrix temp(rows, other.columns);

      for(int r = 0; r < temp.rows; ++r)
      {
         for(int c = 0; c < temp.columns; ++c)
         {
            double t = 0;
            //we add up the pairwise products of the i-th elements
           // row 'r' of the current matrix and column 'c' of the matrix other
            for(int i = 0; i < columns; ++i)
            {
               t += m[r * columns + i] * other.m[i * other.columns + c];
            }
            temp.assign(r, c, t);
         }
      }
      // copy the result to the current object of the matrix this
      this = temp; // calling an overloaded assignment operator
      return &this;
   }

   Matrix operator*(const Matrix &other) const
   {
      Matrix temp(this);
      return temp *= other;
   }

Ahora, multiplicamos la matriz por un número:

   Matrix *operator*=(const double v)
   {
      for(int i = 0; i < ArraySize(m); ++i)
      {
         m[i] *= v;
      }
      return &this;
   }

   Matrix operator*(const double v) const
   {
      Matrix temp(this);
      return temp *= v;
   }

Para comparar dos matrices, disponemos de los operadores '==' y '!=':

   bool operator==(const Matrix &other) const
   {
      return ArrayCompare(m, other.m) == 0;
   }

   bool operator!=(const Matrix &other) const
   {
      return !(this == other);
   }

A efectos de depuración, implementamos la salida del array de la matriz al registro.

   void print() const
   {
      ArrayPrint(m);
   }

Además de las sobrecargas descritas, la clase Matrix dispone adicionalmente de una sobrecarga del operador []: devuelve un objeto de la clase anidada MatrixRow, es decir, una fila con un número dado.

   MatrixRow operator[](int r)
   {
      return MatrixRow(this, r);
   }

La clase MatrixRow en sí proporciona un acceso más «profundo» a los elementos de la matriz sobrecargando el mismo operador [] (es decir, para una matriz, será posible especificar de forma natural dos índices m[i][j]).

   class MatrixRow
   {
   protected:
      const Matrix *owner;
      const int row;

   public:
      class MatrixElement
      {
      protected:
         const MatrixRow *row;
         const int column;

      public:
         MatrixElement(const MatrixRow &mr, const int c) : row(&mr), column(c) { }
         MatrixElement(const MatrixElement &other) : row(other.row), column(other.column) { }

         double operator~() const
         {
            return row.owner.m[row.row * row.owner.columns + column];
         }

         double operator=(const double v)
         {
            row.owner.m[row.row * row.owner.columns + column] = v;
            return v;
         }
      };

      MatrixRow(const Matrix &m, const int r) : owner(&m), row(r) { }
      MatrixRow(const MatrixRow &other) : owner(other.owner), row(other.row) { }

      MatrixElement operator[](int c)
      {
         return MatrixElement(this, c);
      }

      double operator[](uint c)
      {
         return owner.m[row * owner.columns + c];
      }
   };

El operador [] para un parámetro de tipo int devuelve un objeto de clase MatrixElement, a través del cual se puede escribir un elemento específico en el array. Para leer un elemento se utiliza el operador [] con un parámetro de tipo uint. Esto parece un truco, pero es una limitación del lenguaje: las sobrecargas deben diferir en el tipo de parámetro. Como alternativa a la lectura de un elemento, la clase MatrixElement proporciona una sobrecarga del operador '~'.

Cuando se trabaja con matrices, a menudo se necesita una matriz de identidad, así que vamos a crear una clase derivada para ello:

class MatrixIdentity : public Matrix
{
public:
   MatrixIdentity(const int n) : Matrix(n, n)
   {
      for(int i = 0; i < n; ++i)
      {
         m[i * rows + i] = 1;
      }
   }
};

Ahora vamos a probar las expresiones matriciales en acción.

void OnStart()
{
   Matrix m(2, 3), n(3, 2); // description
   MatrixIdentity p(2);     // identity matrix

   double ma[] = {-1,  0, -3,
                   4, -5,  6};
   double na[] = {7,  8,
                  9,  1,
                  2,  3};
   m = ma; // filling in data
   n = na;

   //we can read and write elements separately
   m[0][0] = m[0][(uint)0] + 2; // variant 1
   m[0][1] = ~m[0][1] + 2;      // variant 2

   Matrix r = m * n + p;                    // expression
   Matrix r2 = m.operator*(n).operator+(p); // equivalent
   Print(r == r2); // true

   m.print(); // 1.00000  2.00000 -3.00000  4.00000 -5.00000  6.00000
   n.print(); // 7.00000 8.00000 9.00000 1.00000 2.00000 3.00000
   r.print(); // 20.00000  1.00000 -5.00000  46.00000
}

Aquí hemos creado 2 matrices de 3 por 2 y 2 por 3 dimensiones, respectivamente; luego las hemos rellenado con valores de los arrays y hemos editado el elemento selectivo utilizando la sintaxis de dos índices [][]. Por último, calculamos la expresión m * n + p, donde todos los operandos son matrices. En la línea siguiente se muestra la misma expresión en forma de llamadas a métodos. Tenemos los mismos resultados.

A diferencia de C++, MQL5 no admite la sobrecarga de operadores a nivel global. En MQL5, un operador sólo puede sobrecargarse en el contexto de una clase o estructura, es decir, utilizando su método. Además, MQL5 no admite la sobrecarga de conversión de tipos, operadores new y delete.

Clases abstractas e interfaces

Conversión de tipos de objeto: dynamic_cast y puntero void *