When calling a function with input arguments, MATLAB® copies the values from the calling function’s workspace into the parameter variables in the function being called. However, MATLAB applies various techniques to avoid making copies of these values when it is not necessary.
MATLAB does not provide a way to define a reference to a value, as in languages like C++. Instead, MATLAB allows multiple output as well as multiple input parameters so that you know what values are going into a function and what values are coming out of the function.
If a function does not modify an input argument, MATLAB does not make a copy of the values contained in the input variable.
For example, suppose that you pass a large array to a function.
A = rand(1e7,1); B = f1(A);
f1 multiplies each element in the input array
1.1 and assigns the result to the
function Y = f1(X) Y = X.*1.1; % X is a shared copy of A end
Because the function does not modify the input values, the local variable
X and the variable
A in the caller's
workspace share the data. After
f1 executes, the values
A have not changed. The variable
B in the caller's workspace contains the result of the
element-wise multiplication. The input is passed by value. However, no copy is
made when calling
f2 does modify its local copy of the input
variable, causing the local copy to be unshared with input
The value of
X in the function is now an independent copy of
the input variable
A in the caller's workspace. When
f2 returns the result to the caller's workspace, the
X is destroyed.
A = rand(1e7,1); B = f2(A);
function Y = f2(X) X = X.*1.1; % X is an independent copy of A Y = X; % Y is a shared copy of X end
You can use the value returned from a function as an input argument to another
function. For example, use the
rand function to create the
input for the function
B = f2(rand(1e7,1));
The only variable holding the value returned by
rand is the
X in the workspace of the function
f2. There is no shared or independent copy of these
values in the caller's workspace. Directly passing function outputs saves the
time and memory required to create a copy of the input values in the called
function. This approach makes sense when the input values are not used
You can assign the output of a function to the same variable as the input when you do not need to preserve the original input values.
A = f2(A);
Reassignment to the same variable name follows the copy-on-write behavior described previously: modifying the input variable values results in a temporary copy of those values. However, MATLAB can apply memory optimizations under certain conditions.
Consider the following example. The
function creates a large array of random numbers in the variable
A. Then it calls the local function
A as the input, and
assigning the output of the local function to the same variable name.
Because the call to the local function,
A = fLocal(A),
assigns the output to the variable
A, MATLAB does not need to preserve the original value of
A during execution of the function. Within
fLocal, the input
X has the only copy
of the value originally held by
Therefore, modifications made to
fLocal do not result in a copy of the data. The
X = X.*1.1, modifies
place, without allocating a new array for the result of the
function memoryOptimization A = rand(1e7,1); A = fLocal(A); end function X = fLocal(X) X = X.*1.1; end
Eliminating the copy in the local function saves memory and improves execution
speed for large arrays. However, MATLAB cannot apply memory optimization when it is possible to use the
variable after the function throws an error. Therefore, this optimization is not
applied in scripts, on the command line, in calls to
eval, or to code inside try/catch
Also, MATLAB does not apply memory optimization when the original variable can
be accessed directly during execution of the called function. For example, if
fLocal was a nested function, MATLAB could not apply the optimization because variables can be shared
with the parent function.
Finally, MATLAB does not apply memory optimization when the assigned variable is declared as global or persistent.
MATLAB uses pass-by-value semantics when passing arguments to functions and returning values from functions. In some cases, pass-by-value results in copies of the original values being made in the called function. However, pass-by-value semantics provides certain advantages.
When calling functions, you know that the input variables are not modified in the caller's workspace. Therefore, you do not need to make copies of inputs inside a function or at a call site just to guard against the possibility that these values might be modified. Only the variables assigned to returned values are modified.
Also, you avoid the possibility of corrupting workspace variables if an error occurs within a function that has been passed a variable by reference.
There are special kinds of objects called handles. All variables that hold copies of the same handle can access and modify the same underlying object. Handle objects are useful in specialized circumstances where an object represents a physical object such as a window, plot, device, or person rather than a mathematical object like a number or matrix.
Handle objects derive from the
handle class, which provides
functionality such as events and listeners, destructor methods, and support for