Sobrecarga del operador

Por qué sobrecargar los operadores

Implementando operadores adecuados para su clase, puede integrar objetos de su clase en el lenguaje MATLAB^®. Por ejemplo, los objetos que contienen datos numéricos pueden definir operaciones aritméticas como +, *, - para que pueda utilizar estos objetos en expresiones aritméticas. Implementando operadores relacionales, puede utilizar objetos en instrucciones condicionales, como instrucciones switch y if.

Cómo definir operadores

Puede implementar operadores de MATLAB para trabajar con objetos de su clase. Para implementar operadores, defina los métodos de clase asociados.

Cada operador tiene una función asociada (por ejemplo, el operador + tiene una función plus.m asociada). Puede implementar cualquier operador creando un método de clase con el nombre que corresponda. Este método puede seguir todos los pasos necesarios para la operación que se está implementando.

Para obtener una lista de los operadores y de los nombres de las funciones asociadas, consulte Operadores de MATLAB y funciones asociadas.

Precedencia de los objetos en las operaciones

Las clases definidas por el usuario tienen una mayor precedencia que las clases integradas. Por ejemplo, suponga que q es un objeto de clase double y p es una clase definida por el usuario. Ambas expresiones generan una llamada al método plus en la clase definida por el usuario, si existe:

q + p 
p + q

Si este método puede añadir objetos de clase double y la clase definida por el usuario depende de cómo implemente el método.

Cuando p y q son objetos de distintas clases, MATLAB aplica las reglas de precedencia para determinar qué método utilizar.

Para obtener más información sobre cómo MATLAB determina el método al que debe llamar, consulte Method Invocation.

Precedencia de operadores

Los operadores sobrecargados conservan la precedencia original de MATLAB para el operador. Para obtener más información sobre la precedencia de los operadores, consulte Precedencia de operadores.

Implementación de muestra: objetos que se pueden sumar

La clase Adder implementa la suma para objetos de esta clase definiendo un método plus. Adder define la suma de objetos como la suma de los valores de la propiedad NumericData. El método plus construye y devuelve un objeto Adder cuyo valor de la propiedad NumericData es el resultado de la suma.

La clase Adder también implementa el operador menor que (<) definiendo un método lt. El método lt devuelve un valor lógico después de comparar los valores en cada propiedad NumericData del objeto.

classdef Adder
   properties
      NumericData
   end
   methods
      function obj = Adder(val)
         obj.NumericData = val;
      end
      function r = plus(obj1,obj2)
         a = double(obj1);
         b = double(obj2);
         r = Adder(a + b);
      end
      function d = double(obj)
         d = obj.NumericData;
      end
      function tf = lt(obj1,obj2)
         if obj1.NumericData < obj2.NumericData
            tf = true;
         else
            tf = false;
         end
      end
   end
end

Utilizar un convertidor doble permite añadir valores numéricos a los objetos Adder y realizar sumas en objetos de la clase.

a = Adder(1:10)

a = 

  Adder with properties:

    NumericData: [1 2 3 4 5 6 7 8 9 10]

Sume dos objetos:

a + a

ans = 

  Adder with properties:

    NumericData: [2 4 6 8 10 12 14 16 18 20]

Sume un objeto con cualquier valor que se pueda convertir a doble:

b = uint8(255) + a

b = 

  Adder with properties:

    NumericData: [256 257 258 259 260 261 262 263 264 265]

Compare los objetos a y b utilizando el operador <:

a < b

ans =

     1

Asegúrese de que su clase proporciona las comprobaciones de errores necesarias para implementar su diseño de clase.

Operadores de MATLAB y funciones asociadas

En la siguiente tabla se enumeran los nombres de las funciones para los operadores de MATLAB. Puede que la implementación de operadores para que funcionen con arreglos (expansión escalar, operaciones aritméticas vectorizadas, etc.) también requiera la modificación de la indexación y la concatenación. Utilice los enlaces de esta tabla para encontrar información específica sobre cada función.

Operación	Método que se desea definir	Descripción
`a + b`	`plus(a,b)`	Suma binaria
`a - b`	`minus(a,b)`	Resta binaria
`-a`	`uminus(a)`	Menos unario
`+a`	`uplus(a)`	Más unario
`a.*b`	`times(a,b)`	Multiplicación elemento por elemento
`a*b`	`mtimes(a,b)`	Multiplicación de matrices
`a./b`	`rdivide(a,b)`	División derecha elemento por elemento
`a.\b`	`ldivide(a,b)`	División izquierda elemento por elemento
`a/b`	`mrdivide(a,b)`	División derecha de matrices
`a\b`	`mldivide(a,b)`	División izquierda de matrices
`a.^b`	`power(a,b)`	Potencia elemento por elemento
`a^b`	`mpower(a,b)`	Potencia de matrices
`a < b`	`lt(a,b)`	Menor que
`a > b`	`gt(a,b)`	Mayor que
`a <= b`	`le(a,b)`	Menor que o igual a
`a >= b`	`ge(a,b)`	Mayor que o igual a
`a ~= b`	`ne(a,b)`	No es igual a
`a == b`	`eq(a,b)`	Igualdad
`a & b`	`and(a,b)`	AND lógico
`a \| b`	`or(a,b)`	OR lógico
`~a`	`not(a)`	NOT lógico
`a:d:b` `a:b`	`colon(a,d,b)` `colon(a,b)`	Operador de dos puntos
`a'`	`ctranspose(a)`	Traspuesta conjugada compleja
`a.'`	`transpose(a)`	Trasposición de matriz
`[a b]`	`horzcat(a,b,...)`	Concatenación horizontal
`[a; b]`	`vertcat(a,b,...)`	Concatenación vertical
`a(s1,s2,...sn)`	`subsref(a,s)`	Referencia con subíndices
`a(s1,...,sn) = b`	`subsasgn(a,s,b)`	Asignación con subíndices
`b(a)`	`subsindex(a)`	Indexación de subíndices