Operator Overloading
Why Overload Operators
By implementing operators that are appropriate for your class, you can integrate objects of your class into the MATLAB^{®} language. For example, objects that contain numeric data can define arithmetic operations like +
, *
, 
so that you can use these objects in arithmetic expressions. By implementing relational operators, you can use objects in conditional statements, like switch
and if
statements.
How to Define Operators
You can implement MATLAB operators to work with objects of your class. To implement operators, define the associated class methods.
Each operator has an associated function (e.g., the + operator has an associated plus.m
function). You can implement any operator by creating a class method with the appropriate name. This method can perform whatever steps are appropriate for the operation being implemented.
For a list of operators and associated function names, see MATLAB Operators and Associated Functions.
Object Precedence in Operations
Userdefined classes have a higher precedence than builtin classes. For example, suppose q
is an object of class double
and p
is a userdefined class. Both of these expressions generate a call to the plus
method in the userdefine class, if it exists:
q + p p + q
Whether this method can add objects of class double
and the userdefined class depends on how you implement the method.
When p
and q
are objects of different classes, MATLAB applies the rules of precedence to determine which method to use.
Object Precedence in Method Invocation provides information on how MATLAB determines which method to call.
Operator Precedence
Overloaded operators retain the original MATLAB precedence for the operator. For information on operator precedence, see Operator Precedence.
Sample Implementation — Addable Objects
The Adder
class implements addition for objects of this class by defining a plus
method. Adder
defines addition of objects as the addition of the NumericData
property values. The plus
method constructs and returns an Adder
object whose NumericData
property value is the result of the addition.
The Adder
class also implements the less than operator (<
) by defining a lt
method. The lt
method returns a logical value after comparing the values in each object NumericData
property.
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
Using a double converter enables you to add numeric values to Adder
objects and to perform addition on objects of the class.
a = Adder(1:10)
a = Adder with properties: NumericData: [1 2 3 4 5 6 7 8 9 10]
Add two objects:
a + a
ans = Adder with properties: NumericData: [2 4 6 8 10 12 14 16 18 20]
Add an object with any value that can be cast to double:
b = uint8(255) + a
b = Adder with properties: NumericData: [256 257 258 259 260 261 262 263 264 265]
Compare objects a
and b
using the <
operator:
a < b
ans = 1
Ensure that your class provides any error checking required to implement your class design.
MATLAB Operators and Associated Functions
The following table lists the function names for MATLAB operators. Implementing operators to work with arrays (scalar expansion, vectorized arithmetic operations, and so on), can also require modifying indexing and concatenation. Use the links in this table to find specific information on each function.
Operation  Method to Define  Description 


 Binary addition 

 Binary subtraction 

 Unary minus 

 Unary plus 

 Elementwise multiplication 

 Matrix multiplication 

 Right elementwise division 

 Left elementwise division 

 Matrix right division 

 Matrix left division 

 Elementwise power 

 Matrix power 

 Less than 

 Greater than 
 le (a,b)  Less than or equal to 
 ge (a,b)  Greater than or equal to 
 ne (a,b)  Not equal to 
 eq (a,b)  Equality 
 and (a,b)  Logical AND 
 or (a,b)  Logical OR 
 not (a)  Logical NOT 

 Colon operator 

 Complex conjugate transpose 

 Matrix transpose 

 Horizontal concatenation 

 Vertical concatenation 

 Subscripted reference 

 Subscripted assignment 

 Subscript index 